modules/discourse/discourse_interface.py

# modules/discourse/discourse/discourse_interface.py

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
import plotly.graph_objects as go
import logging
import io  # <-- Añade esta importación

from ..utils.widget_utils import generate_unique_key
from .discourse_process import perform_discourse_analysis
from ..database.chat_mongo_db import store_chat_history
from ..database.discourse_mongo_db import store_student_discourse_result

logger = logging.getLogger(__name__)

#############################################################################################
def display_discourse_interface(lang_code, nlp_models, discourse_t):
    """
    Interfaz para el análisis del discurso
    Args:
        lang_code: Código del idioma actual
        nlp_models: Modelos de spaCy cargados
        discourse_t: Diccionario de traducciones
    """
    try:
        # 1. Inicializar estado si no existe
        if 'discourse_state' not in st.session_state:
            st.session_state.discourse_state = {
                'analysis_count': 0,
                'last_analysis': None,
                'current_files': None
            }

        # 2. Título y descripción
        # st.subheader(discourse_t.get('discourse_title', 'Análisis del Discurso'))
        st.info(discourse_t.get('initial_instruction', 
            'Cargue dos archivos de texto para realizar un análisis comparativo del discurso.'))

        # 3. Área de carga de archivos
        col1, col2 = st.columns(2)
        with col1:
            st.markdown(discourse_t.get('file1_label', "**Documento 1 (Patrón)**"))
            uploaded_file1 = st.file_uploader(
                discourse_t.get('file_uploader1', "Cargar archivo 1"),
                type=['txt'],
                key=f"discourse_file1_{st.session_state.discourse_state['analysis_count']}"
            )

        with col2:
            st.markdown(discourse_t.get('file2_label', "**Documento 2 (Comparación)**"))
            uploaded_file2 = st.file_uploader(
                discourse_t.get('file_uploader2', "Cargar archivo 2"),
                type=['txt'],
                key=f"discourse_file2_{st.session_state.discourse_state['analysis_count']}"
            )

        # 4. Botón de análisis
        col1, col2, col3 = st.columns([1,2,1])
        with col1:
            analyze_button = st.button(
                discourse_t.get('discourse_analyze_button', 'Comparar textos'),
                key=generate_unique_key("discourse", "analyze_button"),
                type="primary",
                icon="🔍",
                disabled=not (uploaded_file1 and uploaded_file2),
                use_container_width=True
            )

        # 5. Proceso de análisis
        if analyze_button and uploaded_file1 and uploaded_file2:
            try:
                with st.spinner(discourse_t.get('processing', 'Procesando análisis...')):
                    # Leer contenido de archivos
                    text1 = uploaded_file1.getvalue().decode('utf-8')
                    text2 = uploaded_file2.getvalue().decode('utf-8')

                    # Realizar análisis
                    result = perform_discourse_analysis(
                        text1, 
                        text2, 
                        nlp_models[lang_code],
                        lang_code
                    )

                    if result['success']:
                        # Guardar estado
                        st.session_state.discourse_result = result
                        st.session_state.discourse_state['analysis_count'] += 1
                        st.session_state.discourse_state['current_files'] = (
                            uploaded_file1.name,
                            uploaded_file2.name
                        )

                        # Guardar en base de datos
                        if store_student_discourse_result(
                            st.session_state.username,
                            text1,
                            text2,
                            result
                        ):
                            st.success(discourse_t.get('success_message', 'Análisis guardado correctamente'))
                            
                            # Mostrar resultados
                            display_discourse_results(result, lang_code, discourse_t)
                        else:
                            st.error(discourse_t.get('error_message', 'Error al guardar el análisis'))
                    else:
                        st.error(discourse_t.get('analysis_error', 'Error en el análisis'))

            except Exception as e:
                logger.error(f"Error en análisis del discurso: {str(e)}")
                st.error(discourse_t.get('error_processing', f'Error procesando archivos: {str(e)}'))

        # 6. Mostrar resultados previos
        elif 'discourse_result' in st.session_state and st.session_state.discourse_result is not None:
            if st.session_state.discourse_state.get('current_files'):
                st.info(
                    discourse_t.get('current_analysis_message', 'Mostrando análisis de los archivos: {} y {}')
                    .format(*st.session_state.discourse_state['current_files'])
                )
            display_discourse_results(
                st.session_state.discourse_result,
                lang_code,
                discourse_t
            )

    except Exception as e:
        logger.error(f"Error general en interfaz del discurso: {str(e)}")
        st.error(discourse_t.get('general_error', 'Se produjo un error. Por favor, intente de nuevo.'))



#####################################################################################################################
def display_discourse_results(result, lang_code, discourse_t):
    """
    Muestra los resultados del análisis del discurso
    Versión actualizada con:
    - Un solo expander para interpretación
    - Botón de descarga combinado
    - Sin mensaje de "próxima actualización"
    - Estilo consistente con semantic_interface
    """
    if not result.get('success'):
        st.warning(discourse_t.get('no_results', 'No hay resultados disponibles'))
        return

    # Estilo CSS unificado
    st.markdown("""
    <style>
    .concept-table {
        display: flex;
        flex-wrap: wrap;
        gap: 10px;
        margin-bottom: 20px;
    }
    .concept-item {
        background-color: #f0f2f6;
        border-radius: 5px;
        padding: 8px 12px;
        display: flex;
        align-items: center;
        gap: 8px;
    }
    .concept-name {
        font-weight: bold;
    }
    .concept-freq {
        color: #666;
        font-size: 0.9em;
    }
    .download-btn-container {
        display: flex;
        justify-content: center;
        margin-top: 15px;
    }
    </style>
    """, unsafe_allow_html=True)

    # Mostrar conceptos clave para ambos documentos
    col1, col2 = st.columns(2)
    
    # Documento 1
    with col1:
        st.subheader(discourse_t.get('compare_doc1_title', 'Documento 1'))
        if 'key_concepts1' in result:
            df1 = pd.DataFrame(
                result['key_concepts1'],
                columns=[discourse_t.get('concept', 'Concepto'), discourse_t.get('frequency', 'Frecuencia')]
            )
            st.write(
                '<div class="concept-table">' + 
                ''.join([
                    f'<div class="concept-item"><span class="concept-name">{concept}</span>'
                    f'<span class="concept-freq">({freq:.2f})</span></div>'
                    for concept, freq in df1.values
                ]) + "</div>",
                unsafe_allow_html=True
            )
            
            if 'graph1' in result and result['graph1']:
                st.image(result['graph1'], use_container_width=True)

    # Documento 2
    with col2:
        st.subheader(discourse_t.get('compare_doc2_title', 'Documento 2'))
        if 'key_concepts2' in result:
            df2 = pd.DataFrame(
                result['key_concepts2'],
                columns=[discourse_t.get('concept', 'Concepto'), discourse_t.get('frequency', 'Frecuencia')]
            )
            st.write(
                '<div class="concept-table">' + 
                ''.join([
                    f'<div class="concept-item"><span class="concept-name">{concept}</span>'
                    f'<span class="concept-freq">({freq:.2f})</span></div>'
                    for concept, freq in df2.values
                ]) + "</div>",
                unsafe_allow_html=True
            )
            
            if 'graph2' in result and result['graph2']:
                st.image(result['graph2'], use_container_width=True)

    # Sección unificada de interpretación (como semantic_interface)
    st.markdown("""
    <style>
    div[data-testid="stExpander"] div[role="button"] p {
        text-align: center;
        font-weight: bold;
    }
    </style>
    """, unsafe_allow_html=True)
    
    with st.expander("📊 " + discourse_t.get('semantic_graph_interpretation', "Interpretación de los gráficos")):
        st.markdown(f"""
        - 🔀 {discourse_t.get('compare_arrow_meaning', 'Las flechas indican la dirección de la relación entre conceptos')}
        - 🎨 {discourse_t.get('compare_color_meaning', 'Los colores más intensos indican conceptos más centrales en el texto')}
        - ⭕ {discourse_t.get('compare_size_meaning', 'El tamaño de los nodos representa la frecuencia del concepto')}
        - ↔️ {discourse_t.get('compare_thickness_meaning', 'El grosor de las líneas indica la fuerza de la conexión')}
        """)

    # Botón de descarga combinado (para ambas imágenes)
    if 'graph1' in result and 'graph2' in result and result['graph1'] and result['graph2']:
        # Crear figura combinada
        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 10))
        
        # Mostrar primer gráfico
        if isinstance(result['graph1'], bytes):
            img1 = plt.imread(io.BytesIO(result['graph1']))
            ax1.imshow(img1)
        ax1.axis('off')
        ax1.set_title(discourse_t.get('compare_doc1_title', 'Documento 1'))
        
        # Mostrar segundo gráfico
        if isinstance(result['graph2'], bytes):
            img2 = plt.imread(io.BytesIO(result['graph2']))
            ax2.imshow(img2)
        ax2.axis('off')
        ax2.set_title(discourse_t.get('compare_doc2_title', 'Documento 2'))
        
        plt.tight_layout()
        
        # Convertir a bytes
        buf = io.BytesIO()
        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
        buf.seek(0)
        
        # Botón de descarga
        st.markdown('<div class="download-btn-container">', unsafe_allow_html=True)
        st.download_button(
            label="📥 " + discourse_t.get('download_both_graphs', "Descargar ambos gráficos"),
            data=buf,
            file_name="comparison_graphs.png",
            mime="image/png",
            use_container_width=True
        )
        st.markdown('</div>', unsafe_allow_html=True)
        
        plt.close()