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
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
    """
    if not result.get('success'):
        st.warning(discourse_t.get('no_results', 'No hay resultados disponibles'))
        return

    # Estilo CSS
    st.markdown("""
        <style>
        .concepts-container {
            display: flex;
            flex-wrap: nowrap;
            gap: 8px;
            padding: 12px;
            background-color: #f8f9fa;
            border-radius: 8px;
            overflow-x: auto;
            margin-bottom: 15px;
            white-space: nowrap;
        }
        .concept-item {
            background-color: white;
            border-radius: 4px;
            padding: 6px 10px;
            display: inline-flex;
            align-items: center;
            gap: 4px;
            box-shadow: 0 1px 2px rgba(0,0,0,0.1);
            flex-shrink: 0;
        }
        .concept-name {
            font-weight: 500;
            color: #1f2937;
            font-size: 0.85em;
        }
        .concept-freq {
            color: #6b7280;
            font-size: 0.75em;
        }
        .graph-container {
            background-color: white;
            padding: 15px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
            margin-top: 10px;
        }
        </style>
    """, unsafe_allow_html=True)

    col1, col2 = st.columns(2)

    # Documento 1
    with col1:
        st.subheader(discourse_t.get('doc1_title', 'Documento 1'))
        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
        if 'key_concepts1' in result:
            concepts_html = f"""
                <div class="concepts-container">
                    {''.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 result['key_concepts1']
                    ])}
                </div>
            """
            st.markdown(concepts_html, unsafe_allow_html=True)

            # Verificar el tipo de graph1 de manera más robusta
            if 'graph1' in result:
                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
                
                # Más información para depuración
                graph_type = type(result['graph1']).__name__
                graph_size = len(result['graph1']) if isinstance(result['graph1'], bytes) else "N/A"
                logger.info(f"Tipo de graph1: {graph_type}, Tamaño: {graph_size}")
                
                if isinstance(result['graph1'], bytes) and len(result['graph1']) > 0:
                    # Es bytes válidos
                    st.image(result['graph1'])
                elif isinstance(result['graph1'], plt.Figure):
                    # Es una figura de matplotlib
                    st.pyplot(result['graph1'])
                elif result['graph1'] is None:
                    # Es None
                    st.warning("Gráfico no disponible")
                else:
                    # Otro tipo o bytes vacíos
                    st.warning(f"Formato de gráfico no reconocido: {graph_type}")
                
                # Botones y controles
                button_col1, spacer_col1 = st.columns([1,4])
                with button_col1:
                    if 'graph1_bytes' in result:
                        st.download_button(
                            label="📥 " + discourse_t.get('download_graph', "Download"),
                            data=result['graph1_bytes'],
                            file_name="discourse_graph1.png",
                            mime="image/png",
                            use_container_width=True
                        )

                # Interpretación como texto normal sin expander
                st.markdown("**📊 Interpretación del grafo:**")
                st.markdown("""
                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
                """)
                
                st.markdown('</div>', unsafe_allow_html=True)
            else:
                st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
        else:
            st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))

    # Documento 2
    with col2:
        st.subheader(discourse_t.get('doc2_title', 'Documento 2'))
        st.markdown(discourse_t.get('key_concepts', 'Conceptos Clave'))
        if 'key_concepts2' in result:
            concepts_html = f"""
                <div class="concepts-container">
                    {''.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 result['key_concepts2']
                    ])}
                </div>
            """
            st.markdown(concepts_html, unsafe_allow_html=True)

            # Verificar el tipo de graph1 de manera más robusta
            if 'graph1' in result:
                st.markdown('<div class="graph-container">', unsafe_allow_html=True)
                
                # Más información para depuración
                graph_type = type(result['graph2']).__name__
                graph_size = len(result['graph2']) if isinstance(result['graph2'], bytes) else "N/A"
                logger.info(f"Tipo de graph2: {graph_type}, Tamaño: {graph_size}")
                
                if isinstance(result['graph2'], bytes) and len(result['graph2']) > 0:
                    # Es bytes válidos
                    st.image(result['graph2'])
                elif isinstance(result['graph2'], plt.Figure):
                    # Es una figura de matplotlib
                    st.pyplot(result['graph2'])
                elif result['graph2'] is None:
                    # Es None
                    st.warning("Gráfico no disponible")
                else:
                    # Otro tipo o bytes vacíos
                    st.warning(f"Formato de gráfico no reconocido: {graph_type}")
                
                # Botones y controles
                button_col2, spacer_col2 = st.columns([1,4])
                with button_col2:
                    if 'graph2_bytes' in result:
                        st.download_button(
                            label="📥 " + discourse_t.get('download_graph', "Download"),
                            data=result['graph2_bytes'],
                            file_name="discourse_graph2.png",
                            mime="image/png",
                            use_container_width=True
                        )

                # Interpretación como texto normal sin expander
                st.markdown("**📊 Interpretación del grafo:**")
                st.markdown("""
                    - 🔀 Las flechas indican la dirección de la relación entre conceptos
                    - 🎨 Los colores más intensos indican conceptos más centrales en el texto
                    - ⭕ El tamaño de los nodos representa la frecuencia del concepto
                    - ↔️ El grosor de las líneas indica la fuerza de la conexión
                """)
                
                st.markdown('</div>', unsafe_allow_html=True)
            else:
                st.warning(discourse_t.get('graph_not_available', 'Gráfico no disponible'))
        else:
            st.warning(discourse_t.get('concepts_not_available', 'Conceptos no disponibles'))

    # Nota informativa sobre la comparación
    st.info(discourse_t.get('comparison_note', 
        'La funcionalidad de comparación detallada estará disponible en una próxima actualización.'))