#modules/semantic/semantic_interface.py
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
import spacy_streamlit
import io
from io import BytesIO
import base64
import matplotlib.pyplot as plt
import pandas as pd
import re
import logging

# Configuración del logger
logger = logging.getLogger(__name__)

# Importaciones locales
from .semantic_process import (
    process_semantic_input,
    format_semantic_results
)

from ..utils.widget_utils import generate_unique_key
from ..database.semantic_mongo_db import store_student_semantic_result
from ..database.semantic_export import export_user_interactions

def display_semantic_interface(lang_code, nlp_models, semantic_t):
    """
    Interfaz para el análisis semántico con controles alineados horizontalmente
    """
    # Forzar la página a semántico
    st.session_state.page = 'semantic'
    
    # Inicializar estados básicos
    if 'semantic_content' not in st.session_state:
        st.session_state.semantic_content = None
    if 'semantic_analyzed' not in st.session_state:
        st.session_state.semantic_analyzed = False

    # Contenedor principal
    with st.container():
        # Una sola fila para todos los controles
        cols = st.columns([4, 2, 2, 2])
        
        # Columna 1: Carga de archivo
        with cols[0]:
            uploaded_file = st.file_uploader(
                "Upload text file",  # Simplificamos el mensaje
                type=['txt'],
                key="semantic_file_upload"
            )

        # Columna 2: Botón de análisis
        with cols[1]:
            can_analyze = uploaded_file is not None and not st.session_state.semantic_analyzed
            if st.button('Analyze', 
                        disabled=not can_analyze,
                        key="semantic_analyze"):
                if uploaded_file:
                    text_content = uploaded_file.getvalue().decode('utf-8')
                    # Realizar el análisis
                    with st.spinner("Analyzing..."):
                        analysis_result = process_semantic_input(
                            text_content,
                            lang_code,
                            nlp_models,
                            semantic_t
                        )
                        if analysis_result['success']:
                            st.session_state.semantic_result = analysis_result
                            st.session_state.semantic_analyzed = True
                            st.success("Analysis completed!")
                            
                            # Mostrar resultados
                            display_semantic_results(
                                analysis_result,
                                lang_code,
                                semantic_t
                            )

        # Columna 3: Botón de exportación
        with cols[2]:
            if st.button('Export', 
                        disabled=not st.session_state.semantic_analyzed,
                        key="semantic_export"):
                if st.session_state.semantic_analyzed:
                    try:
                        pdf_buffer = export_user_interactions(
                            st.session_state.username, 
                            'semantic'
                        )
                        st.download_button(
                            "Download PDF",
                            data=pdf_buffer,
                            file_name="semantic_analysis.pdf",
                            mime="application/pdf"
                        )
                    except Exception as e:
                        st.error(f"Error exporting: {str(e)}")

        # Columna 4: Botón de nuevo análisis
        with cols[3]:
            if st.button('New Analysis', 
                        disabled=not st.session_state.semantic_analyzed,
                        key="semantic_new"):
                st.session_state.semantic_content = None
                st.session_state.semantic_analyzed = False
                st.session_state.semantic_result = None
                st.rerun()

    # Mostrar resultados si existen
    if st.session_state.semantic_analyzed and 'semantic_result' in st.session_state:
        display_semantic_results(
            st.session_state.semantic_result,
            lang_code,
            semantic_t
        )
    elif not uploaded_file:
        st.info("Please upload a text file to begin analysis")

def display_semantic_results(result, lang_code, semantic_t):
    """
    Muestra los resultados del análisis semántico
    """
    if result is None or not result['success']:
        st.warning(semantic_t.get('no_results', 'No results available'))
        return

    analysis = result['analysis']
    
    # Crear tabs para los resultados
    tab1, tab2 = st.tabs([
        semantic_t.get('concepts_tab', 'Key Concepts Analysis'),
        semantic_t.get('entities_tab', 'Entities Analysis')
    ])
    
    # Tab 1: Conceptos Clave
    with tab1:
        col1, col2 = st.columns(2)
        
        # Columna 1: Lista de conceptos
        with col1:
            st.subheader(semantic_t.get('key_concepts', 'Key Concepts'))
            concept_text = "\n".join([
                f"• {concept} ({frequency:.2f})" 
                for concept, frequency in analysis['key_concepts']
            ])
            st.markdown(concept_text)
        
        # Columna 2: Gráfico de conceptos
        with col2:
            st.subheader(semantic_t.get('concept_graph', 'Concepts Graph'))
            st.image(analysis['concept_graph'])
    
    # Tab 2: Entidades
    with tab2:
        col1, col2 = st.columns(2)
        
        # Columna 1: Lista de entidades
        with col1:
            st.subheader(semantic_t.get('identified_entities', 'Identified Entities'))
            if 'entities' in analysis:
                for entity_type, entities in analysis['entities'].items():
                    st.markdown(f"**{entity_type}**")
                    st.markdown("• " + "\n• ".join(entities))
        
        # Columna 2: Gráfico de entidades
        with col2:
            st.subheader(semantic_t.get('entity_graph', 'Entities Graph'))
            st.image(analysis['entity_graph'])