#modules/semantic/semantic_interface.py
# Importaciones necesarias
import streamlit as st
from streamlit_float import *
from streamlit_antd_components import *
from streamlit.components.v1 import html
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


#modules/semantic/semantic_interface.py
# [Mantener las importaciones igual...]

def display_semantic_interface(lang_code, nlp_models, semantic_t):
    """
    Interfaz para el análisis semántico
    Args:
        lang_code: Código del idioma actual
        nlp_models: Modelos de spaCy cargados
        semantic_t: Diccionario de traducciones semánticas
    """
    try:
        # Inicializar estados si no existen
        if 'semantic_analysis_counter' not in st.session_state:
            st.session_state.semantic_analysis_counter = 0
        if 'semantic_current_file' not in st.session_state:
            st.session_state.semantic_current_file = None
        if 'semantic_page' not in st.session_state:
            st.session_state.semantic_page = 'semantic'

        # Contenedor fijo para los controles
        with st.container():
            st.markdown("### Controls")
            # Opción para cargar archivo con key única
            uploaded_file = st.file_uploader(
                semantic_t.get('file_uploader', 'Upload a text file for analysis'),
                type=['txt'],
                key=f"semantic_file_uploader_{st.session_state.semantic_analysis_counter}",
                on_change=lambda: setattr(st.session_state, 'semantic_current_file', uploaded_file)
            )

            # Botón de análisis deshabilitado si no hay archivo
            col1, col2, col3 = st.columns([1,2,1])
            with col1:
                analyze_button = st.button(
                    semantic_t.get('analyze_button', 'Analyze text'),
                    key=f"semantic_analyze_button_{st.session_state.semantic_analysis_counter}",
                    disabled=not uploaded_file,
                    use_container_width=True
                )

                # Botón de exportación solo visible si hay resultados
                if 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
                    export_button = st.button(
                        semantic_t.get('export_button', 'Export Analysis'),
                        key=f"semantic_export_{st.session_state.semantic_analysis_counter}",
                        use_container_width=True
                    )
                    if export_button:
                        pdf_buffer = export_user_interactions(st.session_state.username, 'semantic')
                        st.download_button(
                            label=semantic_t.get('download_pdf', 'Download PDF'),
                            data=pdf_buffer,
                            file_name="semantic_analysis.pdf",
                            mime="application/pdf",
                            key=f"semantic_download_{st.session_state.semantic_analysis_counter}"
                        )

        st.markdown("---")  # Separador

        # Procesar el análisis cuando se presiona el botón
        if analyze_button and uploaded_file is not None:
            try:
                with st.spinner(semantic_t.get('processing', 'Processing...')):
                    text_content = uploaded_file.getvalue().decode('utf-8')
                    
                    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_analysis_counter += 1
                        
                        # Guardar en la base de datos
                        if store_student_semantic_result(
                            st.session_state.username,
                            text_content,
                            analysis_result['analysis']
                        ):
                            st.success(semantic_t.get('success_message', 'Analysis saved successfully'))
                            # Asegurar que nos mantenemos en la página semántica
                            st.session_state.page = 'semantic'
                            # Mostrar resultados
                            display_semantic_results(
                                analysis_result,
                                lang_code,
                                semantic_t
                            )
                        else:
                            st.error(semantic_t.get('error_message', 'Error saving analysis'))
                    else:
                        st.error(analysis_result['message'])
            except Exception as e:
                logger.error(f"Error en análisis semántico: {str(e)}")
                st.error(semantic_t.get('error_processing', f'Error processing text: {str(e)}'))
        
        # Mostrar resultados previos
        elif 'semantic_result' in st.session_state and st.session_state.semantic_result is not None:
            display_semantic_results(
                st.session_state.semantic_result,
                lang_code,
                semantic_t
            )
        else:
            st.info(semantic_t.get('initial_message', 'Upload a file to begin analysis'))

    except Exception as e:
        logger.error(f"Error general en interfaz semántica: {str(e)}")
        st.error("Se produjo un error. Por favor, intente de nuevo.")

# [Resto del código igual...]