#modules/morphosyntax/morphosyntax_interface.py

#Importaciones generales
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
import spacy
from spacy import displacy
import spacy_streamlit
import pandas as pd
import base64
import re

#Importaciones locales
from .morphosyntax_process import (
    process_morphosyntactic_input,
    format_analysis_results,
    perform_advanced_morphosyntactic_analysis,
    get_repeated_words_colors,
    highlight_repeated_words,
    POS_COLORS,
    POS_TRANSLATIONS
)

from ..utils.widget_utils import generate_unique_key

from ..database.morphosintax_mongo_db import store_student_morphosyntax_result

from ..database.morphosyntax_iterative_mongo_db import (
    store_student_morphosyntax_base,
    store_student_morphosyntax_iteration,
    get_student_morphosyntax_analysis,
    update_student_morphosyntax_analysis,
    delete_student_morphosyntax_analysis,
    get_student_morphosyntax_data
)

import logging
logger = logging.getLogger(__name__)

###########################################################################
def initialize_arc_analysis_state():
    """Inicializa el estado del análisis de arcos y el caché si no existen"""
    # Inicializar estado de análisis
    if 'arc_analysis_state' not in st.session_state:
        st.session_state.arc_analysis_state = {
            'original_text': '',
            'original_analysis': None,
            'iteration_text': '',
            'iteration_analysis': None,
            'analysis_count': 0
        }
        logger.info("Estado de análisis de arcos inicializado")

    # Inicializar caché de análisis
    if 'analysis_cache' not in st.session_state:
        st.session_state.analysis_cache = {}
        logger.info("Caché de análisis inicializado")

###########################################################################

def reset_morpho_state():
    """Resetea el estado del análisis morfosintáctico"""
    if 'arc_analysis_state' in st.session_state:
        st.session_state.arc_analysis_state = {
            'original_text': '',
            'original_analysis': None,
            'iteration_text': '',
            'iteration_analysis': None,
            'analysis_count': 0
        }
############################################################################

def display_original_analysis(container, analysis, lang_code, morpho_t):
    """Muestra el análisis original en el contenedor especificado"""
    with container:
        st.subheader("Análisis Original")
        display_morphosyntax_results(analysis, lang_code, morpho_t)

def display_iteration_analysis(container, analysis, lang_code, morpho_t):
    """Muestra el análisis de cambios en el contenedor especificado"""
    with container:
        st.subheader("Análisis de Cambios")
        display_morphosyntax_results(analysis, lang_code, morpho_t)

############################################################################

def cache_analysis_results(key, result):
    """Almacena resultados de análisis en caché"""
    if not hasattr(st.session_state, 'analysis_cache'):
        initialize_arc_analysis_state()
    st.session_state.analysis_cache[key] = result
    logger.info(f"Resultado almacenado en caché con clave: {key}")

def get_cached_analysis(key):
    """Recupera resultados de análisis del caché"""
    if not hasattr(st.session_state, 'analysis_cache'):
        initialize_arc_analysis_state()
        return None
    return st.session_state.analysis_cache.get(key)


############################################################################
def display_morphosyntax_interface(lang_code, nlp_models, morpho_t):
    try:
        # CSS para layout estable
        st.markdown("""
            <style>
            .stTextArea textarea {
                font-size: 1rem;
                line-height: 1.5;
                min-height: 100px !important;
                height: 100px !important;
            }
            .arc-diagram-container {
                width: 100%;
                padding: 0.5rem;
                margin: 0.5rem 0;
            }
            .divider {
                height: 3px;
                border: none;
                background-color: #333;
                margin: 2rem 0;
            }
            </style>
        """, unsafe_allow_html=True)

        # Asegurar que el tab morfosintáctico permanece activo
        st.session_state.tab_states['morpho_active'] = True
        st.session_state.selected_tab = 1

        # Crear subtabs
        subtabs = st.tabs([
            "Análisis de Diagramas de Arco",
            "Análisis de Categorías",
            "Análisis Morfológico"
        ])

        # Tab de Diagramas de Arco
        with subtabs[0]:
            # Botón de reset
            col1, col2, col3 = st.columns([2,1,2])
            with col1:
                if st.button("Nuevo Análisis", type="secondary", use_container_width=True):
                    st.session_state.arc_analysis_state = {
                        'base_id': None,
                        'original_text': '',
                        'iteration_text': '',
                        'analysis_count': 0
                    }
                    st.rerun()

            # Container principal para análisis
            analysis_container = st.container()
            
            with analysis_container:
                # Entrada de texto original
                text_input = st.text_area(
                    "",
                    value=st.session_state.arc_analysis_state.get('original_text', ''),
                    key=f"original_text_{st.session_state.arc_analysis_state['analysis_count']}",
                    height=100
                )

                # Botón de análisis
                col1, col2, col3 = st.columns([2,1,2])
                with col1:
                    analyze_button = st.button(
                        "Analizar Texto",
                        type="primary",
                        use_container_width=True
                    )

                # Procesar texto original
                if analyze_button and text_input.strip():
                    try:
                        # Realizar análisis base
                        doc = nlp_models[lang_code](text_input)
                        analysis = perform_advanced_morphosyntactic_analysis(
                            text_input,
                            nlp_models[lang_code]
                        )

                        # Guardar análisis base y obtener ID
                        base_id = store_student_morphosyntax_base(
                            st.session_state.username,
                            text_input,
                            analysis['arc_diagrams']
                        )

                        if base_id:
                            # Actualizar estado
                            st.session_state.arc_analysis_state.update({
                                'base_id': base_id,
                                'original_text': text_input,
                                'analysis_count': st.session_state.arc_analysis_state['analysis_count'] + 1
                            })

                            # Mostrar diagrama base
                            display_arc_diagram(doc, analysis)

                            # Línea divisora
                            st.markdown('<hr class="divider">', unsafe_allow_html=True)

                            # Área de iteración
                            with st.form("iteration_form"):
                                iteration_text = st.text_area(
                                    "",
                                    value=text_input,
                                    height=100
                                )

                                col1, col2, col3 = st.columns([2,1,2])
                                with col1:
                                    submitted = st.form_submit_button(
                                        "Analizar Cambios",
                                        type="primary",
                                        use_container_width=True
                                    )

                            # Procesar iteración
                            if submitted and iteration_text.strip():
                                doc_iter = nlp_models[lang_code](iteration_text)
                                analysis_iter = perform_advanced_morphosyntactic_analysis(
                                    iteration_text,
                                    nlp_models[lang_code]
                                )

                                # Guardar iteración
                                iteration_id = store_student_morphosyntax_iteration(
                                    st.session_state.username,
                                    base_id,
                                    text_input,
                                    iteration_text,
                                    analysis_iter['arc_diagrams']
                                )

                                if iteration_id:
                                    # Mostrar diagrama de iteración
                                    display_arc_diagram(doc_iter, analysis_iter)

                    except Exception as e:
                        st.error("Error procesando análisis")
                        logger.error(f"Error: {str(e)}")

        # Otros subtabs mantienen su implementación actual...
        with subtabs[1]:
            st.info("Análisis de Categorías en desarrollo...")
        
        with subtabs[2]:
            st.info("Análisis Morfológico en desarrollo...")

    except Exception as e:
        st.error("Error en la interfaz")
        logger.error(f"Error general en la interfaz: {str(e)}")

############################################################################
def display_arc_diagram(doc, analysis):
    """Muestra un diagrama de arco sin título"""
    try:
        for sent in doc.sents:
            html = displacy.render(sent, style="dep", options={
                "distance": 100,
                "arrow_spacing": 20,
                "word_spacing": 30
            })
            
            # Ajustar tamaño y posición
            html = html.replace('height="375"', 'height="200"')
            html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
            html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
                       lambda m: f'<g transform="translate({m.group(1)},50)"', html)
            
            # Envolver en contenedor con estilo
            html = f'<div class="arc-diagram-container">{html}</div>'
            
            st.write(html, unsafe_allow_html=True)

    except Exception as e:
        logger.error(f"Error en display_arc_diagram: {str(e)}")

####################

def display_morphosyntax_results(result, lang_code, morpho_t):
    """
    Muestra solo el diagrama de arco.
    Args:
        result: Diccionario con el documento procesado y su análisis
        lang_code: Código del idioma
        morpho_t: Diccionario de traducciones
    """
    if result is None:
        return
        
    try:
        doc = result['doc']
        sentences = list(doc.sents)
        for i, sent in enumerate(sentences):
            try:
                st.subheader(f"{morpho_t.get('sentence', 'Sentence')} {i+1}")
                html = displacy.render(sent, style="dep", options={
                    "distance": 100,
                    "arrow_spacing": 20,
                    "word_spacing": 30
                })
                html = html.replace('height="375"', 'height="200"')
                html = re.sub(r'<svg[^>]*>', lambda m: m.group(0).replace('height="450"', 'height="300"'), html)
                html = re.sub(r'<g [^>]*transform="translate\((\d+),(\d+)\)"', 
                            lambda m: f'<g transform="translate({m.group(1)},50)"', html)
                html = f'<div class="arc-diagram-container">{html}</div>'
                st.write(html, unsafe_allow_html=True)
            except Exception as e:
                logger.error(f"Error en diagrama {i}: {str(e)}")
                continue
    except Exception as e:
        logger.error(f"Error en display_morphosyntax_results: {str(e)}")