Update app.py

app.py

@@ -1,43 +1,54 @@
-import streamlit as st
+import os
+import tempfile
 import openai
 from dotenv import load_dotenv
+import PyPDF2
 import nltk
-import os
-import tempfile
 from nltk.tokenize import word_tokenize
 from nltk.corpus import stopwords
 from nltk.stem import SnowballStemmer
-import PyPDF2
-import time
+import pandas as pd
+from fpdf import FPDF
+import streamlit as st
+import requests
 from google.cloud import texttospeech
-from streamlit_webrtc import webrtc_streamer, WebRtcMode, AudioProcessorBase
-from Historial.historial_chat import cargar_historial, guardar_historial
-from agent_functions import menu_df, tomar_pedido_agente, procesar_orden_agente, generar_pdf_orden, obtener_respuesta, generar_mensaje_automatico
+import base64
 
-# Configuración de NLTK
-nltk.download('punkt')
-nltk.download('stopwords')
+nltk.download('punkt', quiet=True)
+nltk.download('stopwords', quiet=True)
 
-# Cargar la clave API desde el archivo .env
+# Cargar las claves API desde el archivo .env
 load_dotenv()
+openai_api_key = os.getenv("OPENAI_API_KEY")
+brevo_api_key = os.getenv("BREVO_API_KEY")
 os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "botidinamix-g.json"
-openai.api_key = os.getenv("OPENAI_API_KEY")
 
-# Función para extraer texto del PDF
+# Verifica que las claves API están configuradas
+if not openai_api_key:
+    st.error("No API key provided for OpenAI. Please set your API key in the .env file.")
+else:
+    openai.api_key = openai_api_key
+
+if not brevo_api_key:
+    st.error("No API key provided for Brevo. Please set your API key in the .env file.")
+
 def extraer_texto_pdf(archivo):
     texto = ""
     if archivo:
         with tempfile.NamedTemporaryFile(delete=False) as temp_file:
             temp_file.write(archivo.read())
             temp_file_path = temp_file.name
-        with open(temp_file_path, 'rb') as file:
-            reader = PyPDF2.PdfReader(file)
-            for page in range(len(reader.pages)):
-                texto += reader.pages[page].extract_text()
-        os.unlink(temp_file_path)
+        try:
+            with open(temp_file_path, 'rb') as file:
+                reader = PyPDF2.PdfReader(file)
+                for page in range(len(reader.pages)):
+                    texto += reader.pages[page].extract_text()
+        except Exception as e:
+            st.error(f"Error al extraer texto del PDF: {e}")
+        finally:
+            os.unlink(temp_file_path)
     return texto
 
-# Función para preprocesar texto
 def preprocesar_texto(texto):
     tokens = word_tokenize(texto, language='spanish')
     tokens = [word.lower() for word in tokens if word.isalpha()]
@@ -47,260 +58,731 @@ def preprocesar_texto(texto):
     tokens = [stemmer.stem(word) for word in tokens]
     return " ".join(tokens)
 
-# Clase para procesar audio
-class AudioProcessor(AudioProcessorBase):
-    def __init__(self):
-        self.audio_bytes = b''
+def obtener_respuesta(pregunta, texto_preprocesado, modelo, temperatura=0.5, assistant_id=""):
+    try:
+        response = openai.ChatCompletion.create(
+            model=modelo,
+            messages=[
+                {"role": "system", "content": "Actua como Galatea la asistente de la clinica Odontologica OMARDENT y resuelve las inquietudes"},
+                {"role": "user", "content": f"{pregunta}\n\nContexto: {texto_preprocesado}"}
+            ],
+            temperature=temperatura
+        )
+        respuesta = response.choices[0].message['content'].strip()
+
+        # Configura la solicitud de síntesis de voz
+        client = texttospeech.TextToSpeechClient()
+        input_text = texttospeech.SynthesisInput(text=respuesta)
+        voice = texttospeech.VoiceSelectionParams(
+            language_code="es-ES", ssml_gender=texttospeech.SsmlVoiceGender.FEMALE
+        )
+        audio_config = texttospeech.AudioConfig(
+            audio_encoding=texttospeech.AudioEncoding.MP3
+        )
+
+        # Realiza la solicitud de síntesis de voz
+        response = client.synthesize_speech(
+            input=input_text, voice=voice, audio_config=audio_config
+        )
+
+        # Reproduce el audio en Streamlit
+        st.audio(response.audio_content, format="audio/mp3")
+        return respuesta
+
+    except openai.OpenAIError as e:
+        st.error(f"Error al comunicarse con OpenAI: {e}")
+        return "Lo siento, no puedo procesar tu solicitud en este momento."
+
+    except Exception as e:
+        st.error(f"Error al generar la respuesta y el audio: {e}")
+        return "Lo siento, ocurrió un error al procesar tu solicitud."
+
+def guardar_en_txt(nombre_archivo, datos):
+    carpeta = "datos_guardados"
+    os.makedirs(carpeta, exist_ok=True)
+    ruta_archivo = os.path.join(carpeta, nombre_archivo)
+    try:
+        with open(ruta_archivo, 'a', encoding='utf-8') as archivo:  # Append mode
+            archivo.write(datos + "\n")
+    except Exception as e:
+        st.error(f"Error al guardar datos en el archivo: {e}")
+    return ruta_archivo
+
+def cargar_desde_txt(nombre_archivo):
+    carpeta = "datos_guardados"
+    ruta_archivo = os.path.join(carpeta, nombre_archivo)
+    try:
+        if os.path.exists(ruta_archivo):
+            with open(ruta_archivo, 'r', encoding='utf-8') as archivo:
+                return archivo.read()
+        else:
+            st.warning("Archivo no encontrado.")
+            return ""
+    except Exception as e:
+        st.error(f"Error al cargar datos desde el archivo: {e}")
+        return ""
+
+def listar_archivos_txt():
+    carpeta = "datos_guardados"
+    try:
+        if not os.path.exists(carpeta):
+            return []
+        archivos = [f for f in os.listdir(carpeta) if f.endswith('.txt')]
+        archivos_ordenados = sorted(archivos, key=lambda x: os.path.getctime(os.path.join(carpeta, x)), reverse=True)
+        return archivos_ordenados
+    except Exception as e:
+        st.error(f"Error al listar archivos: {e}")
+        return []
+
+def generar_pdf(dataframe, titulo, filename):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt=titulo, ln=True, align='C')
+
+    for i, row in dataframe.iterrows():
+        row_text = ", ".join(f"{col}: {val}" for col, val in row.items())
+        pdf.cell(200, 10, txt=row_text, ln=True)
+    
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_file:
+            pdf.output(tmp_file.name)
+            return tmp_file.name
+    except Exception as e:
+        st.error(f"Error al generar PDF: {e}")
+        return None
+
+def enviar_correo(destinatario, asunto, contenido):
+    url = "https://api.brevo.com/v3/smtp/email"
+    headers = {
+        "accept": "application/json",
+        "api-key": brevo_api_key,
+        "content-type": "application/json"
+    }
+    payload = {
+        "sender": {"email": "tu_correo@dominio.com"},
+        "to": [{"email": destinatario}],
+        "subject": asunto,
+        "htmlContent": contenido
+    }
+    try:
+        response = requests.post(url, json=payload, headers=headers)
+        if response.status_code == 201:
+            st.success(f"Correo enviado a {destinatario}")
+        else:
+            st.error(f"Error al enviar el correo: {response.text}")
+    except Exception as e:
+        st.error(f"Error al enviar el correo: {e}")
+
+def enviar_whatsapp(numero, mensaje):
+    url = "https://api.brevo.com/v3/whatsapp/send"
+    headers = {
+        "accept": "application/json",
+        "api-key": brevo_api_key,
+        "content-type": "application/json"
+    }
+    payload = {
+        "recipient": {"number": numero},
+        "sender": {"number": "tu_numero_whatsapp"},
+        "content": mensaje
+    }
+    try:
+        response = requests.post(url, json=payload, headers=headers)
+        if response.status_code == 201:
+            st.success(f"Mensaje de WhatsApp enviado a {numero}")
+        else:
+            st.error(f"Error al enviar el mensaje de WhatsApp: {response.text}")
+    except Exception as e:
+        st.error(f"Error al enviar el mensaje de WhatsApp: {e}")
+
+def flujo_laboratorio():
+    st.title("🦷 Gestión de Trabajos de Laboratorio")
+
+    if 'laboratorio' not in st.session_state:
+        st.session_state.laboratorio = []
+
+    with st.form("laboratorio_form"):
+        tipo_trabajo = st.selectbox("Tipo de trabajo:", [
+            "Protesis total", "Protesis removible metal-acrilico", "Parcialita acrilico",
+            "Placa de blanqueamiento", "Placa de bruxismo", "Corona de acrilico", 
+            "Corona en zirconio", "Protesis flexible", "Acker flexible"
+        ])
+        doctor = st.selectbox("Doctor que requiere el trabajo:", ["Dr. Jose Daniel C", "Dr. Jose Omar C"])
+        fecha_entrega = st.date_input("Fecha de entrega:")
+        fecha_envio = st.date_input("Fecha de envío:")
+        laboratorio = st.selectbox("Laboratorio dental:", ["Ernesto Correa lab", "Formando Sonrisas"])
+        nombre_paciente = st.text_input("Nombre paciente:")
+        observaciones = st.text_input("Observaciones:")
+        numero_orden = st.text_input("Número de orden:")
+        cantidad = st.number_input("Cantidad:", min_value=1, step=1)
+
+        submitted = st.form_submit_button("Registrar Trabajo")
+
+        if submitted:
+            trabajo = {
+                "tipo_trabajo": tipo_trabajo,
+                "doctor": doctor,
+                "fecha_entrega": str(fecha_entrega),
+                "fecha_envio": str(fecha_envio),
+                "laboratorio": laboratorio,
+                "nombre_paciente": nombre_paciente,
+                "observaciones": observaciones,
+                "numero_orden": numero_orden,
+                "cantidad": cantidad,
+                "estado": "pendiente"
+            }
+            st.session_state.laboratorio.append(trabajo)
+            datos_guardados = mostrar_datos_como_texto([trabajo])  # Append only the new entry
+            guardar_en_txt('trabajos_laboratorio.txt', datos_guardados)
+            st.success("Trabajo registrado con éxito.")
+    
+    if st.session_state.laboratorio:
+        st.write("### Trabajos Registrados")
+        df_trabajos = pd.DataFrame(st.session_state.laboratorio)
+        st.write(df_trabajos)
+
+        pdf_file = generar_pdf(df_trabajos, "Registro de Trabajos de Laboratorio", "trabajos_laboratorio.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="trabajos_laboratorio.pdf",
+            mime="application/pdf"
+        )
+
+def flujo_insumos():
+    st.title("📦 Gestión de Insumos")
+
+    if 'insumos' not in st.session_state:
+        st.session_state.insumos = []
+
+    with st.form("insumos_form"):
+        insumo_nombre = st.text_input("Nombre del Insumo:")
+        insumo_cantidad = st.number_input("Cantidad Faltante:", min_value=0, step=1)
+        submitted = st.form_submit_button("Agregar Insumo")
+
+        if submitted and insumo_nombre:
+            insumo = {"nombre": insumo_nombre, "cantidad": insumo_cantidad}
+            st.session_state.insumos.append(insumo)
+            datos_guardados = mostrar_datos_como_texto([insumo])  # Append only the new entry
+            guardar_en_txt('insumos.txt', datos_guardados)
+            st.success(f"Insumo '{insumo_nombre}' agregado con éxito.")
+
+    if st.session_state.insumos:
+        st.write("### Insumos Registrados")
+        insumos_df = pd.DataFrame(st.session_state.insumos)
+        st.write(insumos_df)
+
+        pdf_file = generar_pdf(insumos_df, "Registro de Insumos Faltantes", "insumos.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="insumos_faltantes.pdf",
+            mime="application/pdf"
+        )
+
+def buscar_datos_guardados():
+    st.title("🔍 Buscar Datos Guardados")
+
+    carpeta = "datos_guardados"
+    if not os.path.exists(carpeta):
+        st.info("No se encontraron archivos de datos guardados.")
+        return
+
+    archivos = listar_archivos_txt()
+
+    if archivos:
+        archivo_seleccionado = st.selectbox("Selecciona un archivo para ver:", archivos)
+        
+        if archivo_seleccionado:
+            datos = cargar_desde_txt(archivo_seleccionado)
+            if datos:
+                st.write(f"### Datos del archivo {archivo_seleccionado}")
+                st.text_area("Datos", datos, height=300)
+
+                # Link to download the file
+                try:
+                    with open(os.path.join(carpeta, archivo_seleccionado), 'rb') as file:
+                        st.download_button(
+                            label="📥 Descargar Archivo TXT",
+                            data=file,
+                            file_name=archivo_seleccionado,
+                            mime="text/plain"
+                        )
+                except Exception as e:
+                    st.error(f"Error al preparar la descarga: {e}")
+
+                # Enviar el archivo seleccionado por correo
+                if st.button("Enviar por correo"):
+                    contenido = f"Datos del archivo {archivo_seleccionado}:\n\n{datos}"
+                    enviar_correo("josedcape@gmail.com", f"Datos del archivo {archivo_seleccionado}", contenido)
+
+                # Enviar el archivo seleccionado por WhatsApp
+                if st.button("Enviar por WhatsApp"):
+                    mensaje = f"Datos del archivo {archivo_seleccionado}:\n\n{datos}"
+                    enviar_whatsapp("3114329322", mensaje)
+
+            else:
+                st.warning(f"No se encontraron datos en el archivo {archivo_seleccionado}")
+    else:
+        st.info("No se encontraron archivos de datos guardados.")
+
+def generar_notificaciones_pendientes():
+    if 'laboratorio' not in st.session_state or not st.session_state.laboratorio:
+        st.info("No hay trabajos pendientes.")
+        return
+    
+    pendientes = [trabajo for trabajo in st.session_state.laboratorio if trabajo["estado"] == "pendiente"]
+    if pendientes:
+        st.write("### Notificaciones de Trabajos Pendientes")
+        for trabajo in pendientes:
+            st.info(f"Pendiente: {trabajo['tipo_trabajo']} - {trabajo['numero_orden']} para {trabajo['doctor']}. Enviado a {trabajo['laboratorio']} el {trabajo['fecha_envio']}.")
+
+def mostrar_datos_como_texto(datos):
+    texto = ""
+    if isinstance(datos, dict):
+        for key, value in datos.items():
+            texto += f"{key}: {value}\n"
+    elif isinstance(datos, list):
+        for item in datos:
+            if isinstance(item, dict):
+                for key, value in item.items():
+                    texto += f"{key}: {value}\n"
+                texto += "\n"
+            else:
+                texto += f"{item}\n"
+    return texto
 
-    def recv(self, frame):
-        self.audio_bytes += frame.to_ndarray().tobytes()
-        return frame
+def flujo_presupuestos():
+    st.title("💰 Asistente de Presupuestos")
+    st.markdown("Hola Dr. cuénteme en que puedo ayudarle?")
+
+    lista_precios = {
+        "Restauraciones en resina de una superficie": 75000,
+        "Restauraciones en resina de dos superficies": 95000,
+        "Restauraciones en resina de tres o más superficies": 120000,
+        "Restauración en resina cervical": 60000,
+        "Coronas metal-porcelana": 750000,
+        "Provisional": 80000,
+        "Profilaxis simple": 75000,
+        "Profilaxis completa": 90000,
+        "Corona en zirconio": 980000,
+        "Blanqueamiento dental láser por sesión": 150000,
+        "Blanqueamiento dental casero": 330000,
+        "Blanqueamiento mixto": 430000,
+        "Prótesis parcial acrílico hasta 6 dientes": 530000,
+        "Prótesis parcial acrílico de más de 6 dientes": 580000,
+        "Prótesis flexible hasta 6 dientes": 800000,
+        "Prótesis flexible de más de 6 dientes": 900000,
+        "Prótesis total de alto impacto": 650000,
+        "Acker flexible hasta 2 dientes": 480000,
+        "Exodoncia por diente": 85000,
+        "Exodoncia cordal": 130000,
+        "Endodoncia con dientes terminados en 6": 580000,
+        "Endodoncia de un conducto": 380000,
+        "Endodoncia de premolares superiores": 480000,
+    }
+
+    if 'presupuesto' not in st.session_state:
+        st.session_state['presupuesto'] = []
+
+    with st.form("presupuesto_form"):
+        tratamiento = st.selectbox("Selecciona el tratamiento", list(lista_precios.keys()))
+        cantidad = st.number_input("Cantidad", min_value=1, step=1)
+        agregar = st.form_submit_button("Agregar al Presupuesto")
+
+        if agregar:
+            precio_total = lista_precios[tratamiento] * cantidad
+            st.session_state['presupuesto'].append({"tratamiento": tratamiento, "cantidad": cantidad, "precio_total": precio_total})
+            st.success(f"Agregado: {cantidad} {tratamiento} - Total: {precio_total} COP")
+
+    if st.session_state['presupuesto']:
+        st.write("### Servicios Seleccionados")
+        total_presupuesto = sum(item['precio_total'] for item in st.session_state['presupuesto'])
+        for item in st.session_state['presupuesto']:
+            st.write(f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP")
+        st.write(f"**Total: {total_presupuesto} COP**")
+
+        if st.button("Copiar Presupuesto al Asistente"):
+            servicios = "\n".join([f"{item['cantidad']} x {item['tratamiento']} - {item['precio_total']} COP" for item in st.session_state['presupuesto']])
+            total = f"**Total: {total_presupuesto} COP**"
+            st.session_state['presupuesto_texto'] = f"{servicios}\n{total}"
+            st.success("Presupuesto copiado al asistente de chat.")
+            st.session_state['mostrar_chat'] = True
+
+    if st.session_state['mostrar_chat']:
+        st.markdown("### Chat con Asistente")
+        pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", value=st.session_state.get('presupuesto_texto', ''))
+        if st.button("Enviar Pregunta"):
+            manejar_pregunta_usuario(pregunta_usuario)
+
+def flujo_radiografias():
+    st.title("📸 Registro de Radiografías")
+
+    if 'radiografias' not in st.session_state:
+        st.session_state.radiografias = []
+
+    with st.form("radiografias_form"):
+        nombre_paciente = st.text_input("Nombre del Paciente:")
+        tipo_radiografia = st.selectbox("Tipo de Radiografía:", ["Periapical", "Panorámica", "Cefalométrica"])
+        fecha_realizacion = st.date_input("Fecha de Realización:")
+        observaciones = st.text_area("Observaciones:")
+        
+        submitted = st.form_submit_button("Registrar Radiografía")
+
+        if submitted:
+            radiografia = {
+                "nombre_paciente": nombre_paciente,
+                "tipo_radiografia": tipo_radiografia,
+                "fecha_realizacion": str(fecha_realizacion),
+                "observaciones": observaciones
+            }
+            st.session_state.radiografias.append(radiografia)
+            datos_guardados = mostrar_datos_como_texto([radiografia])
+            guardar_en_txt('radiografias.txt', datos_guardados)
+            st.success("Radiografía registrada con éxito.")
+
+    if st.session_state.radiografias:
+        st.write("### Radiografías Registradas")
+        df_radiografias = pd.DataFrame(st.session_state.radiografias)
+        st.write(df_radiografias)
+
+        pdf_file = generar_pdf(df_radiografias, "Registro de Radiografías", "radiografias.pdf")
+        st.download_button(
+            label="📥 Descargar PDF",
+            data=open(pdf_file, 'rb').read(),
+            file_name="radiografias.pdf",
+            mime="application/pdf"
+        )
+
+def mostrar_recomendaciones():
+    st.title("⭐ Recomendaciones")
+    st.write("Aquí puedes encontrar recomendaciones y consejos útiles.")
 
-# Main App
 def main():
-    # --- Diseño general ---
-    st.set_page_config(page_title="Asistente Virtual", page_icon="🤖")
+    st.set_page_config(page_title="Galatea OMARDENT", layout="wide")
+    
+    # Inicializar el estado de la sesión
+    if 'modelo' not in st.session_state:
+        st.session_state['modelo'] = "gpt-3.5-turbo"
+    if 'temperatura' not in st.session_state:
+        st.session_state['temperatura'] = 0.5
+    if 'mensajes_chat' not in st.session_state:
+        st.session_state['mensajes_chat'] = []
+    if 'transcripcion_voz' not in st.session_state:
+        st.session_state['transcripcion_voz'] = ""
+    if 'imagen_asistente' not in st.session_state:
+        st.session_state['imagen_asistente'] = None
+    if 'video_estado' not in st.session_state:
+        st.session_state['video_estado'] = 'paused'
+    if 'assistant_id' not in st.session_state:
+        st.session_state['assistant_id'] = 'asst_4ZYvBvf4IUVQPjnugSZGLdV2'
+    if 'presupuesto_texto' not in st.session_state:
+        st.session_state['presupuesto_texto'] = ''
+    if 'mostrar_chat' not in st.session_state:
+        st.session_state['mostrar_chat'] = False
+    if 'memoria' not in st.session_state:
+        st.session_state['memoria'] = {}
+
+    # Barra lateral
+    ruta_logo = os.path.join("assets", "Logo Omardent.png")
+    if os.path.exists(ruta_logo):
+        st.sidebar.image(ruta_logo, use_column_width=True)
+    else:
+        st.sidebar.warning(f"Error: No se pudo encontrar la imagen en la ruta: {ruta_logo}")
+
+    st.sidebar.title("🤖 Galatea OMARDENT")
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🧠 Configuración del Modelo")
+    st.session_state['modelo'] = st.sidebar.selectbox(
+        "Selecciona el modelo:",
+        ["gpt-3.5-turbo", "gpt-4", "gpt-4-32k", "gpt-4o"],
+        index=0,
+        key='modelo_selectbox',  # Clave única
+        help="Elige el modelo de lenguaje de OpenAI que prefieras."
+    )
+    st.sidebar.markdown("---")
+    st.session_state['temperatura'] = st.sidebar.slider(
+        "🌡️ Temperatura",
+        min_value=0.0, max_value=1.0,
+        value=st.session_state['temperatura'],
+        step=0.1,
+        key='temperatura_slider'  # Clave única
+    )
+    assistant_id = st.sidebar.text_input("Assistant ID", key="assistant_id", help="Introduce el Assistant ID del playground de OpenAI")
+    
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🌟 Navegación")
+    lateral_page = st.sidebar.radio("Ir a", ["Página Principal", "Gestión de Trabajos", "Gestión de Insumos", "Registro de Radiografías", "Buscar Datos", "Notificaciones", "Recomendaciones", "Asistente de Presupuestos", "Comunicación", "Asistente de Agendamiento"])
+
+    top_page = st.selectbox("Navegación Superior", ["Página Principal", "Galatea-Asistente"])
+
+    if top_page == "Galatea-Asistente":
+        mostrar_galatea_asistente()
+    else:
+        if lateral_page == "Página Principal":
+            mostrar_pagina_principal()
+        elif lateral_page == "Gestión de Trabajos":
+            flujo_laboratorio()
+        elif lateral_page == "Gestión de Insumos":
+            flujo_insumos()
+        elif lateral_page == "Registro de Radiografías":
+            flujo_radiografias()
+        elif lateral_page == "Buscar Datos":
+            buscar_datos_guardados()
+        elif lateral_page == "Notificaciones":
+            generar_notificaciones_pendientes()
+        elif lateral_page == "Recomendaciones":
+            mostrar_recomendaciones()
+        elif lateral_page == "Asistente de Presupuestos":
+            flujo_presupuestos()
+        elif lateral_page == "Comunicación":
+            st.write("Página de Comunicación")  # Implementar según sea necesario
+        elif lateral_page == "Asistente de Agendamiento":
+            st.write("Página de Agendamiento")  # Implementar según sea necesario
+
+def mostrar_pagina_principal():
+    st.title("VIRTUAL OMARDENT AI-BOTIDINAMIX")
+    st.markdown(
+        f"""
+        <style>
+        #video-container {{
+            position: relative;
+            width: 100%;
+            padding-bottom: 56.25%;
+            background-color: lightblue;
+            overflow: hidden;
+        }}
+        #background-video {{
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }}
+        </style>
+        <div id="video-container">
+            <video id="background-video" autoplay loop muted playsinline>
+                <source src="https://cdn.leonardo.ai/users/645c3d5c-ca1b-4ce8-aefa-a091494e0d09/generations/0c4f0fe7-5937-4644-b984-bdbd95018990/0c4f0fe7-5937-4644-b984-bdbd95018990.mp4" type="video/mp4">
+            </video>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+    archivo_pdf = st.file_uploader("📂 Cargar PDF", type='pdf', key='chat_pdf')
 
-    # --- Estilos CSS personalizados ---
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        pregunta_usuario = st.text_input("Pregunta:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
+    with col2:
+        capturar_voz()
+    
+    if pregunta_usuario:
+        manejar_pregunta_usuario(pregunta_usuario, archivo_pdf)
+
+def mostrar_galatea_asistente():
     st.markdown(
         """
         <style>
-            body {
-                background: rgb(241,241,234);
-                background: radial-gradient(circle, rgba(241,241,234,1) 4%, rgba(255,127,8,1) 36%, rgba(235,255,8,1) 94%, rgba(0,0,255,1) 99%);
-            }
-            h1, h2, h3, h4, h5, h6 {
-                color: green !important;
-                font-weight: bold !important;
-            }
-            .stChatFloatingInputContainer {
-                background-color: rgba(255, 255, 255, 0.8);
-                border-radius: 10px;
-            }
-            .stTextInput > div > div > input {
-                color: #333;
-            }
-            [data-testid="stChatMessage"] {
-                background-color: black !important;
-                color: gold !important;
-                border-radius: 10px;
-            }
-            [data-testid="stChatMessage"] p {
-                color: gold !important;
-            }
-            ::-webkit-scrollbar {
-                width: 16px;
-            }
-            ::-webkit-scrollbar-thumb {
-                background-color: #FFD700;
-                border-radius: 10px;
-            }
-            .st-spinner > div {
-                border-top-color: transparent;
-                border-right-color: transparent;
-                animation: spin 1s linear infinite;
-            }
-            @keyframes spin {
-                from { transform: rotate(0deg); }
-                to { transform: rotate(360deg); }
-            }
+        #video-container {
+            position: relative;
+            width: 100%;
+            height: 40vh;
+            background-color: lightblue;
+            overflow: hidden;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+        }
+        #background-video {
+            width: 100%;
+            height: auto;
+        }
+        #chat-container {
+            margin-top: 20px;
+            width: 100%;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+        }
+        .chat-message {
+            background: rgba(255, 255, 255, 0.8);
+            border-radius: 10px;
+            padding: 10px;
+            margin-bottom: 10px;
+            max-width: 70%;
+        }
+        .chat-message.user {
+            align-self: flex-start;
+        }
+        .chat-message.assistant {
+            align-self: flex-end;
+            background: rgba(0, 123, 255, 0.8);
+            color: white;
+        }
         </style>
+        <div id="video-container">
+            <video id="background-video" autoplay loop muted playsinline>
+                <source src="https://cdn.pika.art/v1/081128be-944b-4999-9c2e-16f61d7e7a83/lip_sync.mp4" type="video/mp4">
+            </video>
+        </div>
+        <div id="chat-container">
         """,
-        unsafe_allow_html=True,
+        unsafe_allow_html=True
     )
 
-    # --- Barra lateral ---
-    with st.sidebar:
-        st.image("hamburguesa napolitana.jpg")
-        st.title("🤖 RESTAURANTE SAZON BURGER 🍔✨-BOTIDINAMIX AI")
-        st.markdown("---")
-
-        # Opciones de navegación
-        pagina = st.selectbox("Selecciona una página", ["Chat", "Subir PDF", "Agentes"])
-
-    # --- Página principal ---
-    if pagina == "Chat":
-        mostrar_chat()
-    elif pagina == "Subir PDF":
-        mostrar_subir_pdf()
-    elif pagina == "Agentes":
-        mostrar_agentes()
-
-def mostrar_chat():
-    # --- Botones de historial ---
-    if st.button("Buscar Historial"):
-        st.session_state.mostrar_historial = True
-    if st.button("Borrar Historial"):
-        st.session_state.mensajes = []
-        st.session_state.mostrar_historial = False
-        st.success("Historial borrado correctamente")
-
-    # --- Chatbot ---
-    if 'mensajes' not in st.session_state:
-        st.session_state.mensajes = cargar_historial()
-
-    for mensaje in st.session_state.mensajes:
-        with st.chat_message(mensaje["role"]):
-            st.markdown(mensaje["content"])
-
-    # Función para manejar la entrada de audio
-    def on_audio(audio_bytes):
-        with st.spinner("Transcribiendo..."):
-            transcript = openai.Audio.transcribe("whisper-1", audio_bytes)
-            pregunta_usuario = transcript["text"]
-            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
-            with st.chat_message("user"):
-                st.markdown(pregunta_usuario)
-
-    st.subheader("🎤 Captura de voz")
-    st.info("Haz clic en el micrófono y comienza a hablar. Tu pregunta se transcribirá automáticamente.")
-    with st.container():
-        if st.button("Grabar 🎙️"):
-            st.session_state.run_webrtc = True
-        if st.session_state.get("run_webrtc", False):
-            webrtc_ctx = webrtc_streamer(
-                key="example",
-                mode=WebRtcMode.SENDONLY,
-                audio_receiver_size=256,
-                rtc_configuration={
-                    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
-                },
-                media_stream_constraints={"audio": True},
-                audio_processor_factory=AudioProcessor,
-            )
-
-            if webrtc_ctx.audio_receiver:
-                audio_frames = webrtc_ctx.audio_receiver.get_frames(timeout=1)
-                for audio_frame in audio_frames:
-                    audio_bytes = audio_frame.to_ndarray().tobytes()
-                    on_audio(audio_bytes)
-
-    st.markdown("---")
-    st.subheader("📄 Subir PDF")
-    st.info("Sube un archivo PDF y el asistente responderá en función de su contenido.")
-    archivo_pdf = st.file_uploader("Selecciona un archivo PDF", type=["pdf"])
-
-    texto_extraido = ""
-    if archivo_pdf:
-        texto_extraido = extraer_texto_pdf(archivo_pdf)
-        st.success("Texto extraído del PDF exitosamente.")
-        st.text_area("Texto extraído", value=texto_extraido, height=200)
-
-    if not texto_extraido:
-        texto_extraido = st.text_area("Texto extraído", height=200)
-
-    texto_preprocesado = preprocesar_texto(texto_extraido)
-
-    # --- Opciones de entrada de usuario ---
-    st.markdown("---")
-    pregunta_usuario = st.text_input("Escribe tu pregunta:")
-    if st.button("Enviar"):
-        if pregunta_usuario:
-            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
-            with st.chat_message("user"):
-                st.markdown(pregunta_usuario)
-
-            with st.spinner("Generando respuesta..."):
-                respuesta, audio_path = obtener_respuesta(pregunta_usuario, texto_preprocesado, modelo="gpt-4", temperatura=0.5)
-                st.session_state.mensajes.append({"role": "assistant", "content": respuesta, "timestamp": time.time()})
-                with st.chat_message("assistant"):
-                    st.markdown(respuesta)
-                st.audio(audio_path, format="audio/mp3", start_time=0)
-
-            guardar_historial(st.session_state.mensajes)
-        else:
-            st.warning("Por favor, ingresa una pregunta antes de enviar.")
+    for mensaje in st.session_state['mensajes_chat']:
+        clase = "user" if mensaje["role"] == "user" else "assistant"
+        st.markdown(f'<div class="chat-message {clase}">{mensaje["content"]}</div>', unsafe_allow_html=True)
 
-def mostrar_subir_pdf():
-    st.subheader("📄 Subir PDF")
-    st.info("Sube un archivo PDF y el asistente responderá en función de su contenido.")
-    archivo_pdf = st.file_uploader("Selecciona un archivo PDF", type=["pdf"])
+    pregunta_usuario = st.text_input("Escribe tu pregunta aquí:", key='unique_chat_input_key', value=st.session_state['transcripcion_voz'])
+    if st.button("Enviar Pregunta"):
+        manejar_pregunta_usuario(pregunta_usuario)
 
-    texto_extraido = ""
+    st.markdown("</div>", unsafe_allow_html=True)
+
+    if st.session_state['imagen_asistente']:
+        st.image(st.session_state['imagen_asistente'], use_column_width=True)
+    else:
+        st.warning("No se ha cargado ninguna imagen. Por favor, carga una imagen en la página principal.")
+
+def manejar_pregunta_usuario(pregunta_usuario, archivo_pdf=None):
+    st.session_state['mensajes_chat'].append({"role": "user", "content": pregunta_usuario})
+    with st.chat_message("user"):
+        st.markdown(pregunta_usuario)
+
+    texto_preprocesado = ""
     if archivo_pdf:
-        texto_extraido = extraer_texto_pdf(archivo_pdf)
-        st.success("Texto extraído del PDF exitosamente.")
-        st.text_area("Texto extraído", value=texto_extraido, height=200)
-
-    if not texto_extraido:
-        texto_extraido = st.text_area("Texto extraído", height=200)
-
-    texto_preprocesado = preprocesar_texto(texto_extraido)
-
-    # --- Opciones de entrada de usuario ---
-    st.markdown("---")
-    pregunta_usuario = st.text_input("Escribe tu pregunta:")
-    if st.button("Enviar"):
-        if pregunta_usuario:
-            st.session_state.mensajes.append({"role": "user", "content": pregunta_usuario, "timestamp": time.time()})
-            with st.chat_message("user"):
-                st.markdown(pregunta_usuario)
-
-            with st.spinner("Generando respuesta..."):
-                respuesta, audio_path = obtener_respuesta(pregunta_usuario, texto_preprocesado, modelo="gpt-4", temperatura=0.5)
-                st.session_state.mensajes.append({"role": "assistant", "content": respuesta, "timestamp": time.time()})
-                with st.chat_message("assistant"):
-                    st.markdown(respuesta)
-                st.audio(audio_path, format="audio/mp3", start_time=0)
-
-            guardar_historial(st.session_state.mensajes)
-        else:
-            st.warning("Por favor, ingresa una pregunta antes de enviar.")
-
-def mostrar_agentes():
-    st.subheader("📋 Menú y Pedidos")
-    st.success("Menú cargado exitosamente. Listo para tomar pedidos.")
-    st.write(menu_df)
-
-    # Captura de pedido
-    st.markdown("Selecciona los items del menú:")
-    items_seleccionados = st.multiselect("Items", menu_df['item'].tolist())
-
-    if st.button("Tomar Pedido"):
-        if items_seleccionados:
-            pedido_usuario = ','.join(items_seleccionados)
-            confirmados = tomar_pedido_agente(pedido_usuario)
-            st.info(f"Pedido confirmado: {confirmados}")
-
-            total = procesar_orden_agente(','.join(confirmados))
-            st.success(f"Total del pedido: ${total}")
-
-            # Generar PDF de la orden
-            order_details = {item: {'price': menu_df[menu_df['item'] == item]['price'].values[0]} for item in confirmados}
-            pdf_path = generar_pdf_orden(order_details)
-            st.markdown(f"[Descargar PDF de la Orden]({pdf_path})", unsafe_allow_html=True)
-
-            # Generar mensaje automático
-            mensaje_automatico = generar_mensaje_automatico(confirmados)
-            st.session_state.mensajes_agente.append({"role": "assistant", "content": mensaje_automatico, "timestamp": time.time()})
-            with st.chat_message("assistant"):
-                st.markdown(mensaje_automatico)
-
-    # --- Chat para Agentes ---
-    st.subheader("Chat con Agentes")
-    if 'mensajes_agente' not in st.session_state:
-        st.session_state.mensajes_agente = []
-
-    for mensaje in st.session_state.mensajes_agente:
-        with st.chat_message(mensaje["role"]):
-            st.markdown(mensaje["content"])
-
-    agente_pregunta = st.text_input("Escribe tu pregunta para el agente:")
-    if st.button("Enviar al Agente"):
-        if agente_pregunta:
-            st.session_state.mensajes_agente.append({"role": "user", "content": agente_pregunta, "timestamp": time.time()})
-            with st.chat_message("user"):
-                st.markdown(agente_pregunta)
-
-            # Procesar la respuesta del agente
-            with st.spinner("El agente está respondiendo..."):
-                respuesta_agente, audio_path = obtener_respuesta(agente_pregunta, '', modelo="gpt-4", temperatura=0.5)
-                st.session_state.mensajes_agente.append({"role": "assistant", "content": respuesta_agente, "timestamp": time.time()})
-                with st.chat_message("assistant"):
-                    st.markdown(respuesta_agente)
-                st.audio(audio_path, format="audio/mp3", start_time=0)
-        else:
-            st.warning("Por favor, ingresa una pregunta antes de enviar.")
+        texto_pdf = extraer_texto_pdf(archivo_pdf)
+        texto_preprocesado = preprocesar_texto(texto_pdf)
+    else:
+        with open("assets/instrucciones.pdf", "rb") as file:
+            texto_pdf = extraer_texto_pdf(file)
+            texto_preprocesado = preprocesar_texto(texto_pdf)
+
+    # Obtener respuesta del modelo usando Assistant ID si está presente
+    assistant_id = st.session_state.get('assistant_id', '')
+    if assistant_id:
+        prompt = f"{texto_preprocesado}\n\n{pregunta_usuario}"
+        response = openai.ChatCompletion.create(
+            model=st.session_state['modelo'],
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=st.session_state['temperatura'],
+            user=assistant_id
+        )
+        respuesta = response.choices[0].message['content'].strip()
+    else:
+        respuesta = obtener_respuesta(
+            pregunta_usuario,
+            texto_preprocesado,
+            st.session_state['modelo'],
+            st.session_state['temperatura'],
+            assistant_id
+        )
+    
+    st.session_state['mensajes_chat'].append({"role": "assistant", "content": respuesta})
+    with st.chat_message("assistant"):
+        st.markdown(respuesta)
+
+    # Convertir la respuesta en voz
+    client = texttospeech.TextToSpeechClient()
+    synthesis_input = texttospeech.SynthesisInput(text=respuesta)
+    voice = texttospeech.VoiceSelectionParams(language_code="es-ES", ssml_gender=texttospeech.SsmlVoiceGender.FEMALE)
+    audio_config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.MP3)
+    response = client.synthesize_speech(input=synthesis_input, voice=voice, audio_config=audio_config)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+        tmp_file.write(response.audio_content)
+        audio_file_path = tmp_file.name
+
+    # Incrustar el audio en la página y reproducirlo automáticamente
+    audio_html = f"""
+    <audio id="response-audio" src="data:audio/mp3;base64,{base64.b64encode(response.audio_content).decode()}" autoplay></audio>
+    <script>
+    document.getElementById('response-audio').onended = function() {{
+        document.getElementById('background-video').pause();
+    }};
+    </script>
+    """
+    st.markdown(audio_html, unsafe_allow_html=True)
+
+    # Reproducir el video solo cuando el chat está activo
+    st.session_state['video_estado'] = 'playing'
+    st.markdown(f"<script>document.getElementById('background-video').play();</script>", unsafe_allow_html=True)
+
+    # Almacenar la información importante en la memoria
+    if "nombre" in pregunta_usuario.lower() or "teléfono" in pregunta_usuario.lower():
+        st.session_state['memoria']['última_interacción'] = pregunta_usuario
+        guardar_en_txt('memoria_asistente.txt', f"Última interacción: {pregunta_usuario}")
+
+def capturar_voz():
+    st.markdown(
+        """
+        <style>
+        .assistant-button {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background-color: #4CAF50;
+            color: white;
+            padding: 10px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            margin-top: 10px;
+        }
+        .assistant-button img {
+            margin-right: 10px;
+        }
+        </style>
+        <button class="assistant-button" onclick="startRecording()">
+            <img src='https://img2.gratispng.com/20180808/cxq/kisspng-robotics-science-computer-icons-robot-technology-robo-to-logo-svg-png-icon-free-download-45527-5b6baa46a5e322.4713113715337825986795.jpg' alt='icon' width='20' height='20'/>
+            Capturar Voz
+        </button>
+        <script>
+            function startRecording() {
+                const recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+                recognition.lang = 'es-ES';
+                recognition.interimResults = false;
+                recognition.maxAlternatives = 1;
+                recognition.start();
+                recognition.onresult = (event) => {
+                    const lastResult = event.results.length - 1;
+                    const text = event.results[lastResult][0].transcript;
+                    const customEvent = new CustomEvent('audioTranscription', { detail: text });
+                    document.dispatchEvent(customEvent);
+                };
+                recognition.onspeechend = () => {
+                    recognition.stop();
+                };
+                recognition.onerror = (event) => {
+                    console.error(event.error);
+                };
+            }
+            document.addEventListener('audioTranscription', (event) => {
+                const transcription = event.detail;
+                document.querySelector("input[name='unique_chat_input_key']").value = transcription;
+                // También puedes actualizar el estado de Streamlit aquí si es necesario
+                fetch('/process_audio', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ transcription })
+                }).then(response => response.json())
+                  .then(data => {
+                      // Manejo de la respuesta de Flask si es necesario
+                  });
+            });
+        </script>
+        """,
+        unsafe_allow_html=True
+    )
 
 if __name__ == "__main__":
     main()