modules/studentact/current_situation_interface.py

# modules/studentact/current_situation_interface.py

import streamlit as st
import logging
from ..utils.widget_utils import generate_unique_key
import matplotlib.pyplot as plt
import numpy as np

from ..database.current_situation_mongo_db import store_current_situation_result

from ..database.writing_progress_mongo_db import (
    store_writing_baseline,
    store_writing_progress,
    get_writing_baseline,
    get_writing_progress,
    get_latest_writing_metrics
)

from .current_situation_analysis import (
    analyze_text_dimensions, 
    analyze_clarity,
    analyze_vocabulary_diversity, 
    analyze_cohesion,
    analyze_structure,
    get_dependency_depths, 
    normalize_score, 
    generate_sentence_graphs, 
    generate_word_connections, 
    generate_connection_paths,
    create_vocabulary_network, 
    create_syntax_complexity_graph, 
    create_cohesion_heatmap     
)

# Configuración del estilo de matplotlib para el gráfico de radar
plt.rcParams['font.family'] = 'sans-serif'
plt.rcParams['axes.grid'] = True
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.spines.right'] = False

logger = logging.getLogger(__name__)
####################################

TEXT_TYPES = {
    'academic_article': {
        'name': 'Artículo Académico',
        'thresholds': {
            'vocabulary': {'min': 0.70, 'target': 0.85},
            'structure': {'min': 0.75, 'target': 0.90},
            'cohesion': {'min': 0.65, 'target': 0.80},
            'clarity': {'min': 0.70, 'target': 0.85}
        }
    },
    'student_essay': {
        'name': 'Trabajo Universitario',
        'thresholds': {
            'vocabulary': {'min': 0.60, 'target': 0.75},
            'structure': {'min': 0.65, 'target': 0.80},
            'cohesion': {'min': 0.55, 'target': 0.70},
            'clarity': {'min': 0.60, 'target': 0.75}
        }
    },
    'general_communication': {
        'name': 'Comunicación General',
        'thresholds': {
            'vocabulary': {'min': 0.50, 'target': 0.65},
            'structure': {'min': 0.55, 'target': 0.70},
            'cohesion': {'min': 0.45, 'target': 0.60},
            'clarity': {'min': 0.50, 'target': 0.65}
        }
    }
}
####################################

ANALYSIS_DIMENSION_MAPPING = {
    'morphosyntactic': {
        'primary': ['vocabulary', 'clarity'],
        'secondary': ['structure'],
        'tools': ['arc_diagrams', 'word_repetition']
    },
    'semantic': {
        'primary': ['cohesion', 'structure'],
        'secondary': ['vocabulary'],
        'tools': ['concept_graphs', 'semantic_networks']
    },
    'discourse': {
        'primary': ['cohesion', 'structure'],
        'secondary': ['clarity'],
        'tools': ['comparative_analysis']
    }
}


##############################################################################
#                           FUNCIÓN PRINCIPAL
##############################################################################
def display_current_situation_interface(lang_code, nlp_models, t):
    """
    TAB:
      - Expander con radio para tipo de texto

    Contenedor-1 (2 "filas" con borde):
       - Fila 1: Métricas base
       - Fila 2: Métricas iteración

    Contenedor-2 (2 columnas):
       - Col1: Texto base
       - Col2: Texto iteración

    Al final, Recomendaciones en una sola línea.
    """
    # --- Inicializar session_state ---
    if 'base_text' not in st.session_state:
        st.session_state.base_text = ""
    if 'iter_text' not in st.session_state:
        st.session_state.iter_text = ""
    if 'base_metrics' not in st.session_state:
        st.session_state.base_metrics = {}
    if 'iter_metrics' not in st.session_state:
        st.session_state.iter_metrics = {}
    if 'show_base' not in st.session_state:
        st.session_state.show_base = False
    if 'show_iter' not in st.session_state:
        st.session_state.show_iter = False

    # Creamos un TAB
    tabs = st.tabs(["Análisis de Texto"])
    with tabs[0]:
        # 1) Expander con radio
        with st.expander("Selecciona el tipo de texto", expanded=True):
            text_type = st.radio(
                "¿Qué tipo de texto quieres analizar?",
                options=list(TEXT_TYPES.keys()),
                format_func=lambda x: TEXT_TYPES[x]['name'],
                index=0
            )
            st.session_state.current_text_type = text_type

        st.markdown("---")

        # ---------------------------------------------------------------------
        # CONTENEDOR-1: Métricas (2 filas con borde)
        # ---------------------------------------------------------------------
        with st.container():
            # Fila 1: Métricas base
            if st.session_state.show_base:
                # Usamos HTML + CSS para enmarcar las métricas en un div con borde
                st.markdown(
                    """
                    <div style="border:1px solid black; padding:10px; margin-bottom:10px;">
                        <p style="font-weight:bold;">Métricas de la línea base</p>
                    """,
                    unsafe_allow_html=True
                )
                # ---- Aquí llamamos a la función que muestra las 4 métricas ----
                display_metrics_in_one_row(st.session_state.base_metrics, text_type)
                # Cerramos el div
                st.markdown("</div>", unsafe_allow_html=True)

            # Fila 2: Métricas de iteración
            if st.session_state.show_iter:
                st.markdown(
                    """
                    <div style="border:1px solid black; padding:10px; margin-bottom:10px;">
                        <p style="font-weight:bold;">Métricas de la iteración</p>
                    """,
                    unsafe_allow_html=True
                )
                display_metrics_in_one_row(st.session_state.iter_metrics, text_type)
                st.markdown("</div>", unsafe_allow_html=True)

        # ---------------------------------------------------------------------
        # CONTENEDOR-2: 2 columnas (texto base | texto iteración)
        # ---------------------------------------------------------------------
        with st.container():
            col_left, col_right = st.columns(2)

            with col_left:
                st.markdown("**Texto base**")
                text_base = st.text_area(
                    label="",
                    value=st.session_state.base_text,
                    key="text_base_area",
                    placeholder="Pega aquí tu texto base"
                )
                if st.button("Analizar Base"):
                    with st.spinner("Analizando texto base..."):
                        doc = nlp_models[lang_code](text_base)
                        metrics = analyze_text_dimensions(doc)
                        st.session_state.base_text = text_base
                        st.session_state.base_metrics = metrics
                        st.session_state.show_base = True
                        # Al analizar base, reiniciamos la iteración
                        st.session_state.show_iter = False

            with col_right:
                st.markdown("**Texto de iteración**")
                text_iter = st.text_area(
                    label="",
                    value=st.session_state.iter_text,
                    key="text_iter_area",
                    placeholder="Edita y mejora tu texto...",
                    disabled=not st.session_state.show_base
                )
                if st.button("Analizar Iteración", disabled=not st.session_state.show_base):
                    with st.spinner("Analizando iteración..."):
                        doc = nlp_models[lang_code](text_iter)
                        metrics = analyze_text_dimensions(doc)
                        st.session_state.iter_text = text_iter
                        st.session_state.iter_metrics = metrics
                        st.session_state.show_iter = True

        # ---------------------------------------------------------------------
        # Recomendaciones al final (una sola línea, por ejemplo)
        # ---------------------------------------------------------------------
        # Solo mostramos si tenemos iteración
        if st.session_state.show_iter:
            # Podríamos mostrar todo en una misma línea usando st.columns(1)
            # o simplemente un st.container(). Lo muestro en un solo contenedor:
            with st.container():
                st.markdown("**Recomendaciones**")
                # Si las quieres en una sola línea, podrías hacer algo como:
                # rec_col = st.columns(1)[0]   # Solo 1 columna
                # con rec_col: ...
                # Pero en general, un for con st.write estará apilado verticalmente.

                # Ejemplo de iterar dimensiones
                any_reco = False
                for dimension, values in st.session_state.iter_metrics.items():
                    score = values['normalized_score']
                    target = TEXT_TYPES[text_type]['thresholds'][dimension]['target']
                    if score < target:
                        suggest_improvement_tools(dimension)
                        any_reco = True

                if not any_reco:
                    st.info("¡No hay recomendaciones! Todas las métricas superan la meta.")


#Funciones de visualización ##################################
##############################################################################
#                  Función para mostrar métricas en una sola fila
##############################################################################
def display_metrics_in_one_line(metrics, text_type):
    """
    Muestra las cuatro dimensiones (Vocabulario, Estructura, Cohesión, Claridad)
    en una sola línea, usando 4 columnas.
    """
    thresholds = TEXT_TYPES[text_type]['thresholds']
    dimensions = ["vocabulary", "structure", "cohesion", "clarity"]

    col1, col2, col3, col4 = st.columns(4)
    cols = [col1, col2, col3, col4]

    for dim, col in zip(dimensions, cols):
        score = metrics[dim]['normalized_score']
        target = thresholds[dim]['target']
        min_val = thresholds[dim]['min']

        # Determinar estado y color
        if score < min_val:
            status = "⚠️ Por mejorar"
            color = "inverse"
        elif score < target:
            status = "📈 Aceptable"
            color = "off"
        else:
            status = "✅ Óptimo"
            color = "normal"

        with col:
            col.metric(
                label=dim.capitalize(),
                value=f"{score:.2f}",
                delta=f"{status} (Meta: {target:.2f})",
                delta_color=color
                border=True
            )


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

def display_metrics_analysis(metrics, text_type=None):
    """
    Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
    """
    try:
        # Usar valor por defecto si no se especifica tipo
        text_type = text_type or 'student_essay'
        
        # Obtener umbrales según el tipo de texto
        thresholds = TEXT_TYPES[text_type]['thresholds']

        # Crear dos columnas para las métricas y el gráfico
        metrics_col, graph_col = st.columns([1, 1.5])
        
        # Columna de métricas
        with metrics_col:
            metrics_config = [
                {
                    'label': "Vocabulario",
                    'key': 'vocabulary',
                    'value': metrics['vocabulary']['normalized_score'],
                    'help': "Riqueza y variedad del vocabulario",
                    'thresholds': thresholds['vocabulary']
                },
                {
                    'label': "Estructura",
                    'key': 'structure',
                    'value': metrics['structure']['normalized_score'],
                    'help': "Organización y complejidad de oraciones",
                    'thresholds': thresholds['structure']
                },
                {
                    'label': "Cohesión",
                    'key': 'cohesion',
                    'value': metrics['cohesion']['normalized_score'],
                    'help': "Conexión y fluidez entre ideas",
                    'thresholds': thresholds['cohesion']
                },
                {
                    'label': "Claridad",
                    'key': 'clarity',
                    'value': metrics['clarity']['normalized_score'],
                    'help': "Facilidad de comprensión del texto",
                    'thresholds': thresholds['clarity']
                }
            ]

            # Mostrar métricas
            for metric in metrics_config:
                value = metric['value']
                if value < metric['thresholds']['min']:
                    status = "⚠️ Por mejorar"
                    color = "inverse"
                elif value < metric['thresholds']['target']:
                    status = "📈 Aceptable"
                    color = "off"
                else:
                    status = "✅ Óptimo"
                    color = "normal"
                
                st.metric(
                    metric['label'],
                    f"{value:.2f}",
                    f"{status} (Meta: {metric['thresholds']['target']:.2f})",
                    delta_color=color,
                    help=metric['help']
                )
                st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)

    except Exception as e:
        logger.error(f"Error mostrando resultados: {str(e)}")
        st.error("Error al mostrar los resultados")

def display_comparison_results(baseline_metrics, current_metrics):
    """Muestra comparación entre línea base y métricas actuales"""
    
    # Crear columnas para métricas y gráfico
    metrics_col, graph_col = st.columns([1, 1.5])
    
    with metrics_col:
        for dimension in ['vocabulary', 'structure', 'cohesion', 'clarity']:
            baseline = baseline_metrics[dimension]['normalized_score']
            current = current_metrics[dimension]['normalized_score']
            delta = current - baseline
            
            st.metric(
                dimension.title(),
                f"{current:.2f}",
                f"{delta:+.2f}",
                delta_color="normal" if delta >= 0 else "inverse"
            )
            
            # Sugerir herramientas de mejora
            if delta < 0:
                suggest_improvement_tools(dimension)
                
    with graph_col:
        display_radar_chart_comparison(
            baseline_metrics,
            current_metrics
        )

def display_metrics_and_suggestions(metrics, text_type, title, show_suggestions=False):
    """
    Muestra métricas y opcionalmente sugerencias de mejora.
    Args:
        metrics: Diccionario con las métricas analizadas
        text_type: Tipo de texto seleccionado
        title: Título para las métricas ("Base" o "Iteración")
        show_suggestions: Booleano para mostrar sugerencias
    """
    try:
        thresholds = TEXT_TYPES[text_type]['thresholds']
        
        st.markdown(f"### Métricas {title}")
        
        for dimension, values in metrics.items():
            score = values['normalized_score']
            target = thresholds[dimension]['target']
            min_val = thresholds[dimension]['min']
            
            # Determinar estado y color
            if score < min_val:
                status = "⚠️ Por mejorar"
                color = "inverse"
            elif score < target:
                status = "📈 Aceptable"
                color = "off"
            else:
                status = "✅ Óptimo"
                color = "normal"
            
            # Mostrar métrica
            st.metric(
                dimension.title(),
                f"{score:.2f}",
                f"{status} (Meta: {target:.2f})",
                delta_color=color,
                help=f"Meta: {target:.2f}, Mínimo: {min_val:.2f}"
            )
            
            # Mostrar sugerencias si es necesario
            if show_suggestions and score < target:
                suggest_improvement_tools(dimension)
            
            # Agregar espacio entre métricas
            st.markdown("<div style='margin-bottom: 0.5rem;'></div>", unsafe_allow_html=True)
            
    except Exception as e:
        logger.error(f"Error mostrando métricas: {str(e)}")
        st.error("Error al mostrar métricas")

def display_radar_chart(metrics_config, thresholds, baseline_metrics=None):
    """
    Muestra el gráfico radar con los resultados.
    Args:
        metrics_config: Configuración actual de métricas
        thresholds: Umbrales para las métricas
        baseline_metrics: Métricas de línea base (opcional)
    """
    try:
        # Preparar datos para el gráfico
        categories = [m['label'] for m in metrics_config]
        values_current = [m['value'] for m in metrics_config]
        min_values = [m['thresholds']['min'] for m in metrics_config]
        target_values = [m['thresholds']['target'] for m in metrics_config]

        # Crear y configurar gráfico
        fig = plt.figure(figsize=(8, 8))
        ax = fig.add_subplot(111, projection='polar')

        # Configurar radar
        angles = [n / float(len(categories)) * 2 * np.pi for n in range(len(categories))]
        angles += angles[:1]
        values_current += values_current[:1]
        min_values += min_values[:1]
        target_values += target_values[:1]

        # Configurar ejes
        ax.set_xticks(angles[:-1])
        ax.set_xticklabels(categories, fontsize=10)
        circle_ticks = np.arange(0, 1.1, 0.2)
        ax.set_yticks(circle_ticks)
        ax.set_yticklabels([f'{tick:.1f}' for tick in circle_ticks], fontsize=8)
        ax.set_ylim(0, 1)

        # Dibujar áreas de umbrales
        ax.plot(angles, min_values, '#e74c3c', linestyle='--', linewidth=1, 
                label='Mínimo', alpha=0.5)
        ax.plot(angles, target_values, '#2ecc71', linestyle='--', linewidth=1, 
                label='Meta', alpha=0.5)
        ax.fill_between(angles, target_values, [1]*len(angles), 
                       color='#2ecc71', alpha=0.1)
        ax.fill_between(angles, [0]*len(angles), min_values, 
                       color='#e74c3c', alpha=0.1)

        # Si hay línea base, dibujarla primero
        if baseline_metrics is not None:
            values_baseline = [baseline_metrics[m['key']]['normalized_score'] 
                             for m in metrics_config]
            values_baseline += values_baseline[:1]
            ax.plot(angles, values_baseline, '#888888', linewidth=2, 
                   label='Línea base', linestyle='--')
            ax.fill(angles, values_baseline, '#888888', alpha=0.1)

        # Dibujar valores actuales
        label = 'Actual' if baseline_metrics else 'Tu escritura'
        color = '#3498db' if baseline_metrics else '#3498db'
        
        ax.plot(angles, values_current, color, linewidth=2, label=label)
        ax.fill(angles, values_current, color, alpha=0.2)

        # Ajustar leyenda
        legend_handles = []
        if baseline_metrics:
            legend_handles.extend([
                plt.Line2D([], [], color='#888888', linestyle='--', 
                          label='Línea base'),
                plt.Line2D([], [], color='#3498db', label='Actual')
            ])
        else:
            legend_handles.extend([
                plt.Line2D([], [], color='#3498db', label='Tu escritura')
            ])
        
        legend_handles.extend([
            plt.Line2D([], [], color='#e74c3c', linestyle='--', label='Mínimo'),
            plt.Line2D([], [], color='#2ecc71', linestyle='--', label='Meta')
        ])

        ax.legend(
            handles=legend_handles,
            loc='upper right',
            bbox_to_anchor=(1.3, 1.1),
            fontsize=10,
            frameon=True,
            facecolor='white',
            edgecolor='none',
            shadow=True
        )

        plt.tight_layout()
        st.pyplot(fig)
        plt.close()

    except Exception as e:
        logger.error(f"Error mostrando gráfico radar: {str(e)}")
        st.error("Error al mostrar el gráfico")

#Funciones auxiliares ##################################
def suggest_improvement_tools(dimension):
    """Sugiere herramientas basadas en la dimensión"""
    suggestions = []
    for analysis, mapping in ANALYSIS_DIMENSION_MAPPING.items():
        if dimension in mapping['primary']:
            suggestions.extend(mapping['tools'])
    
    st.info(f"Herramientas sugeridas para mejorar {dimension}:")
    for tool in suggestions:
        st.write(f"- {tool}")
        
def prepare_metrics_config(metrics, text_type='student_essay'):
    """
    Prepara la configuración de métricas en el mismo formato que display_results.
    Args:
        metrics: Diccionario con las métricas analizadas
        text_type: Tipo de texto para los umbrales
    Returns:
        list: Lista de configuraciones de métricas
    """
    # Obtener umbrales según el tipo de texto
    thresholds = TEXT_TYPES[text_type]['thresholds']
    
    # Usar la misma estructura que en display_results
    return [
        {
            'label': "Vocabulario",
            'key': 'vocabulary',
            'value': metrics['vocabulary']['normalized_score'],
            'help': "Riqueza y variedad del vocabulario",
            'thresholds': thresholds['vocabulary']
        },
        {
            'label': "Estructura", 
            'key': 'structure',
            'value': metrics['structure']['normalized_score'],
            'help': "Organización y complejidad de oraciones",
            'thresholds': thresholds['structure']
        },
        {
            'label': "Cohesión",
            'key': 'cohesion', 
            'value': metrics['cohesion']['normalized_score'],
            'help': "Conexión y fluidez entre ideas",
            'thresholds': thresholds['cohesion']
        },
        {
            'label': "Claridad",
            'key': 'clarity',
            'value': metrics['clarity']['normalized_score'],
            'help': "Facilidad de comprensión del texto",
            'thresholds': thresholds['clarity']
        }
    ]