modules/chatbot/sidebar_chat.py

# modules/chatbot/sidebar_chat.py
import streamlit as st
from .chat_process import ChatProcessor
from ..database.chat_mongo_db import store_chat_history, get_chat_history
import logging

logger = logging.getLogger(__name__)

def display_sidebar_chat(lang_code: str, chatbot_t: dict):
    """
    Muestra el chatbot en el sidebar
    Args:
        lang_code: Código del idioma
        chatbot_t: Diccionario de traducciones del chatbot
    """
    
    # Asegurar que tenemos las traducciones necesarias
    default_translations = {
        'error_message': 'An error occurred',
        'expand_chat': 'Open Assistant',
        'initial_message': 'Hi! How can I help?',
        'input_placeholder': 'Type your message...',
        'clear_chat': 'Clear chat'
    }
    
    # Combinar traducciones por defecto con las proporcionadas
    translations = {**default_translations, **chatbot_t}

    with st.sidebar:
        st.markdown("""
        <style>
            /* Contenedor principal del chat con altura fija y scroll */
            div[data-testid="stExpanderContent"] > div {
                max-height: 60vh;
                overflow-y: auto;
                padding-right: 10px;
            }
            
            /* Fija el input en la parte inferior */
            div[data-testid="stHorizontalBlock"]:has(> div[data-testid="column"]) {
                position: sticky;
                bottom: 0;
                background: white;
                padding-top: 10px;
                z-index: 100;
            }
            
            /* Asegura que el expander no afecte el layout */
            section[data-testid="stSidebar"] > div {
                overflow: visible !important;
            }
        </style>
        """, unsafe_allow_html=True)

        with st.expander(translations['expand_chat'], expanded=False):
            try:
                # Verificar si hay contexto semántico activo
                semantic_context = st.session_state.get('semantic_agent_data')
                
                # Inicializar el chat con contexto especializado si existe
                if semantic_context and 'chat_processor' in st.session_state:
                    st.session_state.chat_processor.set_semantic_context(
                        text=semantic_context['text'],
                        metrics=semantic_context['metrics'],
                        graph_data=semantic_context['graph_data']
                    )

                    try:
                        st.session_state.chat_processor = ChatProcessor()
                        
                        # Mensaje inicial especializado para análisis semántico
                        initial_message = (
                            f"He analizado tu texto con {len(semantic_context['metrics'].get('key_concepts', []))} conceptos clave. "
                            "- ¿Qué aspecto te gustaría discutir? Por ejemplo:\n"
                            "- ¿Por qué estos conceptos son los más centrales?\n"
                            "- ¿Qué patrones ves en las relaciones conceptuales?\n"
                            "- ¿Cómo podrías mejorar la estructura del texto?"
                        )
                        
                        st.session_state.sidebar_messages = [
                            {"role": "assistant", "content": initial_message}
                        ]
                        
                    except Exception as e:
                        logger.error(f"Error inicializando ChatProcessor con contexto semántico: {str(e)}")
                        st.error("Error: No se pudo inicializar el chat especializado.")
                        return
                
                # Inicializar mensajes si no existen
                if 'sidebar_messages' not in st.session_state:
                    # Intentar recuperar historial previo
                    try:
                        history = get_chat_history(st.session_state.username, 'sidebar', 10)
                        if history:
                            st.session_state.sidebar_messages = history[0]['messages']
                        else:
                            st.session_state.sidebar_messages = [
                                {"role": "assistant", "content": translations['initial_message']}
                            ]
                    except Exception as e:
                        logger.error(f"Error recuperando historial: {str(e)}")
                        st.session_state.sidebar_messages = [
                            {"role": "assistant", "content": translations['initial_message']}
                        ]

                # Contenedor del chat
                chat_container = st.container()

                # Mostrar mensajes existentes
                with chat_container:
                    for message in st.session_state.sidebar_messages:
                        with st.chat_message(message["role"]):
                            st.markdown(message["content"])

                # Input del usuario
                user_input = st.text_input(
                    translations['input_placeholder'],
                    key='sidebar_chat_input'
                )

                if user_input:
                    # Agregar mensaje del usuario
                    st.session_state.sidebar_messages.append(
                        {"role": "user", "content": user_input}
                    )
                
                    # Generar y mostrar respuesta
                    with chat_container:
                        with st.chat_message("assistant"):
                            message_placeholder = st.empty()
                            full_response = ""
                            
                            for chunk in st.session_state.chat_processor.process_chat_input(
                                user_input,
                                lang_code
                            ):
                                full_response += chunk
                                message_placeholder.markdown(full_response)
                            
                            # Guardar respuesta
                            st.session_state.sidebar_messages.append(
                                {"role": "assistant", "content": full_response.strip()}
                            )
                                    
                    # En la función donde guardamos el chat
                    store_chat_history(
                        username=st.session_state.username,
                        messages=st.session_state.sidebar_messages,
                        analysis_type='sidebar'  # Especificar el tipo
                    )

                # Botón para limpiar chat
                if st.button(translations['clear_chat']):
                    st.session_state.sidebar_messages = [
                        {"role": "assistant", "content": translations['initial_message']}
                    ]
                    st.rerun()

            except Exception as e:
                logger.error(f"Error en sidebar chat: {str(e)}")
                st.error(translations['error_message'])