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 .current_situation_analysis import (
    analyze_text_dimensions, 
    analyze_clarity,
    analyze_reference_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}
        }
    }
}
####################################

def display_current_situation_interface(lang_code, nlp_models, t):
    """
    Interfaz simplificada con gráfico de radar para visualizar métricas.
    """
    # Inicializar estados si no existen
    if 'text_input' not in st.session_state:
        st.session_state.text_input = ""
    if 'show_results' not in st.session_state:
        st.session_state.show_results = False
    if 'current_doc' not in st.session_state:
        st.session_state.current_doc = None
    if 'current_metrics' not in st.session_state:
        st.session_state.current_metrics = None

    # st.markdown("## Análisis Inicial de Escritura")

    # Añadir selector de tipo de texto
    text_type = st.selectbox(
        "Tipo de texto a analizar:",
        options=list(TEXT_TYPES.keys()),
        format_func=lambda x: TEXT_TYPES[x]['name'],
        help="Selecciona el tipo de texto para ajustar los criterios de evaluación"
    )
    
    # Guardar el tipo seleccionado en session_state
    st.session_state.current_text_type = text_type
    
    try:
        # Container principal con dos columnas
        with st.container():
            input_col, results_col = st.columns([1,2])
            
            with input_col:
                # Definir función para manejar cambios de texto
                def on_text_change():
                    st.session_state.text_input = st.session_state.text_area
                    st.session_state.show_results = False
                
                # Text area con manejo de estado
                text_input = st.text_area(
                    t.get('input_prompt', "Escribe o pega tu texto aquí:"),
                    height=400,
                    key="text_area",
                    value=st.session_state.text_input,
                    on_change=on_text_change,
                    help="Este texto será analizado para darte recomendaciones personalizadas"
                )
                
                if st.button(
                    t.get('analyze_button', "Analizar mi escritura"),
                    type="primary",
                    disabled=not text_input.strip(),
                    use_container_width=True,
                ):
                    try:
                        with st.spinner(t.get('processing', "Analizando...")):
                            doc = nlp_models[lang_code](text_input)
                            metrics = analyze_text_dimensions(doc)
                            
                            storage_success = store_current_situation_result(
                                username=st.session_state.username,
                                text=text_input,
                                metrics=metrics,
                                feedback=None
                            )
                            
                            if not storage_success:
                                logger.warning("No se pudo guardar el análisis en la base de datos")
                            
                            st.session_state.current_doc = doc
                            st.session_state.current_metrics = metrics
                            st.session_state.show_results = True
                            st.session_state.text_input = text_input
                            
                    except Exception as e:
                        logger.error(f"Error en análisis: {str(e)}")
                        st.error(t.get('analysis_error', "Error al analizar el texto"))
            
            # Mostrar resultados en la columna derecha
            with results_col:
                if st.session_state.show_results and st.session_state.current_metrics is not None:
                    display_results(st.session_state.current_metrics)

    except Exception as e:
        logger.error(f"Error en interfaz principal: {str(e)}")
        st.error("Ocurrió un error al cargar la interfaz")

def display_results(metrics):
    """
    Muestra los resultados del análisis: métricas verticalmente y gráfico radar.
    """
    try:
        # Crear dos columnas para métricas y gráfico
        metrics_col, graph_col = st.columns([1, 1.5])
        
        # Configuración de métricas con sus umbrales
        metrics_config = [
            {
                'label': "Vocabulario",
                'key': 'vocabulary',
                'value': metrics['vocabulary']['normalized_score'],
                'help': "Riqueza y variedad del vocabulario",
                'thresholds': {'min': 0.60, 'target': 0.75}
            },
            {
                'label': "Estructura",
                'key': 'structure',
                'value': metrics['structure']['normalized_score'],
                'help': "Organización y complejidad de oraciones",
                'thresholds': {'min': 0.65, 'target': 0.80}
            },
            {
                'label': "Cohesión",
                'key': 'cohesion',
                'value': metrics['cohesion']['normalized_score'],
                'help': "Conexión y fluidez entre ideas",
                'thresholds': {'min': 0.55, 'target': 0.70}
            },
            {
                'label': "Claridad",
                'key': 'clarity',
                'value': metrics['clarity']['normalized_score'],
                'help': "Facilidad de comprensión del texto",
                'thresholds': {'min': 0.60, 'target': 0.75}
            }
        ]

        # Mostrar métricas verticalmente
        with metrics_col:
            st.markdown("""
                <style>
                .metric-container {
                    background-color: #ffffff;
                    padding: 1rem;
                    border-radius: 0.5rem;
                    box-shadow: 0 1px 3px rgba(0,0,0,0.1);
                    margin-bottom: 0.5rem;
                }
                </style>
            """, unsafe_allow_html=True)
            
            for metric in metrics_config:
                with st.container():
                    # Determinar estado basado en umbrales
                    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: 1rem;'></div>", unsafe_allow_html=True)

        # Gráfico radar en la columna derecha
        with graph_col:
            # Preparar datos para el gráfico
            categories = [m['label'] for m in metrics_config]
            values_user = [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_user += values_user[: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)

            # Dibujar valores del usuario
            ax.plot(angles, values_user, '#3498db', linewidth=2, label='Tu escritura')
            ax.fill(angles, values_user, '#3498db', alpha=0.2)

            # Ajustar leyenda
            ax.legend(
                loc='upper right',
                bbox_to_anchor=(0.1, 0.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 resultados: {str(e)}")
        st.error("Error al mostrar los resultados")