#modules/morphosyntax/morphosyntax_interface.py
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
import base64
from .morphosyntax_process import process_morphosyntactic_input, format_analysis_results
from ..utils.widget_utils import generate_unique_key
from ..database.morphosintax_mongo_db import store_student_morphosyntax_result
from ..database.chat_db import store_chat_history
from ..database.morphosintaxis_export import export_user_interactions

import logging
logger = logging.getLogger(__name__)


def display_morphosyntax_interface(lang_code, nlp_models, t):
    """
    Interfaz para el análisis morfosintáctico
    Args:
        lang_code: Código del idioma actual
        nlp_models: Modelos de spaCy cargados
        t: Diccionario de traducciones
    """
    # Asegurarnos de que estamos accediendo al diccionario MORPHOSYNTACTIC
    morpho_t = t.get('MORPHOSYNTACTIC', {})
    
    st.title(morpho_t.get('title', 'AIdeaText - Morphological and Syntactic Analysis'))

    input_key = f"morphosyntax_input_{lang_code}"
    if input_key not in st.session_state:
        st.session_state[input_key] = ""

    sentence_input = st.text_area(
        morpho_t.get('morpho_input_label', 'Enter text to analyze:'),
        height=150,
        placeholder=morpho_t.get('morpho_input_placeholder', 'Enter your text here...'),
        value=st.session_state[input_key],
        key=f"text_area_{lang_code}",
        on_change=lambda: setattr(st.session_state, input_key, st.session_state[f"text_area_{lang_code}"])
    )

    if st.button(morpho_t.get('analyze_button', 'Analyze'), key=f"analyze_button_{lang_code}"):
        current_input = st.session_state[input_key]
        if current_input:
            doc = nlp_models[lang_code](current_input)
            
            # Análisis morfosintáctico avanzado
            advanced_analysis = perform_advanced_morphosyntactic_analysis(current_input, nlp_models[lang_code])
            
            # Guardar el resultado en el estado de la sesión
            st.session_state.morphosyntax_result = {
                'doc': doc,
                'advanced_analysis': advanced_analysis
            }
            
            # Mostrar resultados
            display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, morpho_t)
            
            # Guardar resultados
            if store_morphosyntax_result(
                st.session_state.username,
                current_input,
                get_repeated_words_colors(doc),
                advanced_analysis['arc_diagram'],
                advanced_analysis['pos_analysis'],
                advanced_analysis['morphological_analysis'],
                advanced_analysis['sentence_structure']
            ):
                st.success(morpho_t.get('success_message', 'Analysis saved successfully.'))
            else:
                st.error(morpho_t.get('error_message', 'Error saving analysis.'))
        else:
            st.warning(morpho_t.get('warning_message', 'Please enter a text to analyze.'))
    
    elif 'morphosyntax_result' in st.session_state and st.session_state.morphosyntax_result is not None:
        # Si hay un resultado guardado, mostrarlo
        display_morphosyntax_results(st.session_state.morphosyntax_result, lang_code, morpho_t)
    else:
        st.info(morpho_t.get('morpho_initial_message', 'Enter text to begin analysis.'))


'''
    if user_input:
        # Añadir el mensaje del usuario al historial
        st.session_state.morphosyntax_chat_history.append({"role": "user", "content": user_input})

        # Procesar el input del usuario nuevo al 26-9-2024
        response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)

        # Mostrar indicador de carga
        with st.spinner(t.get('processing', 'Processing...')):
            try:
                # Procesar el input del usuario
                response, visualizations, result = process_morphosyntactic_input(user_input, lang_code, nlp_models, t)

                # Añadir la respuesta al historial
                message = {
                    "role": "assistant",
                    "content": response
                }
                if visualizations:
                    message["visualizations"] = visualizations
                st.session_state.morphosyntax_chat_history.append(message)

                # Mostrar la respuesta más reciente
                with st.chat_message("assistant"):
                    st.write(response)
                    if visualizations:
                        for i, viz in enumerate(visualizations):
                            st.markdown(f"**Oración {i+1} del párrafo analizado**")
                            st.components.v1.html(
                                f"""
                                <div style="width: 100%; overflow-x: auto; white-space: nowrap;">
                                    <div style="min-width: 1200px;">
                                        {viz}
                                    </div>
                                </div>
                                """,
                                height=350,
                                scrolling=True
                            )
                            if i < len(visualizations) - 1:
                                st.markdown("---")  # Separador entre diagramas

                # Si es un análisis, guardarlo en la base de datos
                if user_input.startswith('/analisis_morfosintactico') and result:
                    store_morphosyntax_result(
                        st.session_state.username,
                        user_input.split('[', 1)[1].rsplit(']', 1)[0],  # texto analizado
                        result.get('repeated_words', {}),
                        visualizations,
                        result.get('pos_analysis', []),
                        result.get('morphological_analysis', []),
                        result.get('sentence_structure', [])
                    )


            except Exception as e:
                st.error(f"{t['error_processing']}: {str(e)}")



    # Forzar la actualización de la interfaz
        st.rerun()

    # Botón para limpiar el historial del chat
    if st.button(t['clear_chat'], key=generate_unique_key('morphosyntax', 'clear_chat')):
        st.session_state.morphosyntax_chat_history = []
        st.rerun()
'''


'''
############ MODULO PARA DEPURACIÓN Y PRUEBAS #####################################################
def display_morphosyntax_interface(lang_code, nlp_models, t):
    st.subheader(t['morpho_title'])

    text_input = st.text_area(
        t['warning_message'],
        height=150,
        key=generate_unique_key("morphosyntax", "text_area")
    )

    if st.button(
        t['results_title'],
        key=generate_unique_key("morphosyntax", "analyze_button")
    ):
        if text_input:
            # Aquí iría tu lógica de análisis morfosintáctico
            # Por ahora, solo mostraremos un mensaje de placeholder
            st.info(t['analysis_placeholder'])
        else:
            st.warning(t['no_text_warning'])
###
#################################################
'''