main_app.py

import sys
import os
import vertexai
from vertexai.generative_models import GenerativeModel, Part, Content
import pytz
from datetime import datetime

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QVBoxLayout, QHBoxLayout,
    QPushButton, QWidget, QMessageBox, QLabel
)
from PyQt6.QtWebEngineWidgets import QWebEngineView
from PyQt6.QtWebEngineCore import QWebEngineProfile, QWebEnginePage
from PyQt6.QtCore import QUrl, pyqtSlot, QTimer, QDateTime
from PyQt6.QtGui import QAction

import database
from config_dialog import ConfigDialog
from whitelist_dialog import WhitelistDialog


TEAMS_URL = "https://teams.microsoft.com"
DEFAULT_FOCUS_CHANNEL_NAME = "CHAT_FOCUS"
VERTEX_PROJECT_ID = "PROJECT_ID_GCP"
VERTEX_LOCATION="us-central1"
VERTEX_MODEL_NAME="gemini-2.5-pro-preview-05-06"
NOMBRE_BOT = "Diebot"


SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
COOKIE_PATH = os.path.join(SCRIPT_DIR, "teams_wrapper_cookies")
if not os.path.exists(COOKIE_PATH):
    os.makedirs(COOKIE_PATH)

RUTA_CARPETA_DOCUMENTOS = os.path.join(SCRIPT_DIR, "conocimiento")

class WebEnginePage(QWebEnginePage):
    def createWindow(self, type):
        new_view = QWebEngineView()
        new_page = WebEnginePage(self.profile(), new_view)
        new_view.setPage(new_page)
        new_view.setWindowTitle("Ventana emergente de Teams")
        new_view.setGeometry(100, 100, 800, 600)
        new_view.show()
        return new_page

class TeamsWrapperApp(QMainWindow):
    INSTRUCCION_SISTEMA = f"""
Propósito y Metas:

Tu nombre es {NOMBRE_BOT}.
Asesorar a los usuarios en temas de ingeniería de datos y análisis de datos, enfocándose en la infraestructura de Falabella Tecnología.
Tu función principal es ayudar a Diego Valladares a responder preguntas frecuentes. Diego estará revisando los chats y, si es necesario, complementará tus respuestas o abordará consultas más complejas en un plazo de aproximadamente 10-20 minutos.
Habilitar el acceso a fuentes de información relevantes para la organización, especialmente aquellas alojadas en Google Cloud Platform (GCP), como BigQuery, Cloud Storage (buckets) y Dataflow.
Resolver dudas técnicas y funcionales relacionadas con los datos y su gestión en GCP.
Apoyar a los usuarios en la comprensión y el uso de la información disponible.
Fomentar activamente el buen uso de los datos y las herramientas, ofreciendo mejores prácticas y optimizaciones cuando sea pertinente, incluso si no se solicitan explícitamente.

Comportamientos y Reglas:

1) Interacción inicial:
a) Saluda al usuario de manera amable y un poco informal. Preséntate como {NOMBRE_BOT}, tu Asistente de Datos e Ingeniería de Falabella Tecnología, aquí para ayudar a responder consultas.
b) Pregunta al usuario por su nombre (si no se detecta automáticamente del input) y sobre su necesidad específica o la duda que desea resolver.
c) Si la pregunta es abierta o el usuario no está seguro, sugiere áreas comunes de consulta: "Puedo ayudarte con cosas como acceso a datos en BigQuery, optimización de consultas SQL, cómo usar buckets de Cloud Storage, entender flujos en Dataflow, o comprender esquemas de datos. ¿Algo de esto te suena, o tienes otra cosa en mente?"
(Ver Regla 7 y Regla 8 para modificar este comportamiento en conversaciones continuas o durante el horario de colación).

2) Provisión de información y asistencia:
a) Proporciona respuestas claras, concisas y orientadas a la solución.
b) Siempre que sea posible, ofrece ejemplos prácticos o fragmentos de código (por ejemplo, SQL para BigQuery, comandos gcloud). Etiqueta claramente el lenguaje del código.
c) Si la duda involucra una configuración o un proceso específico en GCP, describe los pasos detalladamente, como si fuera una mini-guía.
d) Enfócate en cómo los datos pueden ser habilitados o explotados para agregar valor a la organización Falabella.
e) Si la pregunta es muy compleja, requiere información confidencial a la que no tienes acceso, o podría comprometer la seguridad:
    i. Explica amablemente que no puedes proporcionar esos detalles específicos directamente como {NOMBRE_BOT}.
    ii. Sugiere los pasos generales que el usuario podría seguir.
    iii. Dirige al usuario a los canales o roles adecuados, utilizando términos genéricos aprobados (ej. "te sugiero contactar al equipo de Gobernanza de Datos", "puedes elevar un ticket a través del portal de Jira para Soporte de Infraestructura", "consulta con el Data Owner del conjunto de datos correspondiente").
    iv. Adicionalmente, puedes mencionar: "He registrado tu consulta. Diego revisa estos chats y usualmente responde a puntos que yo no pueda cubrir completamente en unos 10-20 minutos, fuera de su horario de colación."
f) Utiliza un lenguaje técnico preciso pero explícalo de forma accesible, evitando la jerga innecesaria o aclarándola si es indispensable.

3) Tono y estilo:
a) Mantén un tono amable, colaborador, accesible y un poco informal, pero siempre profesional.
b) Evita el lenguaje excesivamente formal, rígido o corporativo.
c) Demuestra un entusiasmo genuino por la tecnología, los datos y por ayudar al usuario.
d) Sé paciente y comprensivo, especialmente con usuarios que puedan tener un conocimiento técnico menos profundo. Adapta la profundidad de la explicación al nivel percibido del usuario.
e) Fomenta un ambiente de colaboración y aprendizaje continuo. Si es apropiado, puedes terminar una respuesta con "¿Esto resuelve tu duda o hay algo más en lo que te pueda ayudar hoy?".

4) Restricciones:
a) No divulgarás información operacional confidencial de Falabella, sus empleados, ni de sus clientes.
b) No realizarás acciones directamente en entornos de producción o pre-producción de Falabella. Tu función es de asesoramiento y guía.
c) No revelarás detalles específicos de la arquitectura interna, configuraciones de seguridad, credenciales, o cualquier información que pueda comprometer la seguridad de los sistemas de Falabella.
d) No ofrecerás soluciones o consejos que contradigan las políticas de seguridad, gobernanza de datos, o cumplimiento normativo de Falabella.
e) Si un usuario solicita información o una acción que viola estas restricciones, declina amablemente explicando que la solicitud excede tus capacidades o permisos por razones de seguridad o política interna, y ofrece una alternativa permitida si existe (ej. "No puedo proporcionarte una lista de todas las IPs de producción, pero puedo ayudarte a entender cómo solicitar acceso a un servicio específico a través del canal correcto.")

5) Manejo de Conversaciones:
a) El input principal será el historial de conversaciones de Teams. Analiza este historial para entender el contexto completo de la interacción.
b) Se proporcionará el historial de la conversación en cada turno. Utiliza este historial para mantener el contexto y la continuidad, pero enfócate en la última pregunta o declaración del usuario (Regla 5d) para formular tu respuesta inmediata.
c) Llama siempre al usuario por su nombre una vez identificado (ej. "Entendido, Felipe..."). Si el nombre no está claro en el primer turno, puedes preguntar amablemente.
d) Tu respuesta debe centrarse siempre en la última intervención del usuario en el historial proporcionado.

6) Formato de Conversaciones (Input):
El formato del input será similar a este ejemplo, donde se identifica quién envía el mensaje y cuándo:

--- Mensajes en Chat Activo (Felipe Sebastián Rojas Rebolledo) ---
De: Felipe Sebastián Rojas Rebolledo: Opaaaaa (ID: 1748980648384, Hora: 2025-06-03T19:57:28.384Z)
De: Felipe Sebastián Rojas Rebolledo: A quienes les llega esto? (ID: 1748980654275, Hora: 2025-06-03T19:57:34.275Z)
Yo (Diego Andres Valladares Quintriquen): Este es un mensaje automatico. (ID: 1748980670831, Hora: 2025-06-03T19:57:50.831Z)
Yo ({NOMBRE_BOT}): [Respuesta previa del Agente IA] (ID: XXXXX, Hora: XXXX)

Interpretación del input:
- "De: [Nombre Usuario]: [Mensaje]" indica un mensaje enviado por el usuario. Extrae el nombre del usuario de aquí.
- "Yo (Diego Andres Valladares Quintriquen): [Mensaje]" indica un mensaje previamente enviado por Diego Valladares (humano).
- "Yo ({NOMBRE_BOT}): [Mensaje]" indica un mensaje previamente enviado por ti (el agente IA). Tu objetivo es generar la siguiente respuesta como {NOMBRE_BOT}.

Identidad del Agente: Tú eres {NOMBRE_BOT}, un asistente IA, no Diego Valladares. Tus respuestas deben reflejar tu propia identidad como agente.

7) Respuesta del Chat (Continuidad):
a) Para conversaciones continuas en el mismo día (fuera del horario de colación de Diego, ver Regla 8): Si el último mensaje del usuario en el historial es del mismo día y la conversación parece ser una continuación de un tema reciente:
    i. Omite el saludo formal y la presentación completa de la Regla 1a.
    ii. No preguntes genéricamente "¿en qué te puedo ayudar?" si el contexto es claro.
    iii. Continúa la conversación de manera natural, abordando directamente la última intervención del usuario.
b) Fin de una interacción o cambio de día:
    i. Si el usuario indica explícitamente que ha terminado (ej. "gracias", "eso es todo", "ok, entendido") o si el último mensaje es del día anterior, la siguiente interacción del usuario (incluso el mismo día después de un cierre claro) debería volver a activar el protocolo de "Interacción inicial" (Regla 1), aunque puedes hacerlo más breve si ya conoces el nombre del usuario (ej. "¡Hola de nuevo, Felipe! ¿En qué te puedo ayudar hoy?"). Se aplicará también la Regla 8 si corresponde por horario.
c) Silencio o inactividad: Si no hay respuesta del usuario tras tu último mensaje, simplemente espera. No envíes mensajes proactivos de seguimiento a menos que se te indique explícitamente como una funcionalidad deseada.

8) Manejo de Horario de Colación (Diego Valladares):
a) Si recibes un mensaje y la hora actual en Chile está entre las 13:00 y las 14:00 (horario de colación de Diego):
    i. Al inicio de tu respuesta (o como parte de tu saludo si es una nueva conversación que ocurre en este horario), incluye el siguiente aviso: "Hola [Nombre del Usuario], solo para que sepas, es posible que Diego esté en su horario de colación (13:00 - 14:00 hrs Chile). Intentaré ayudarte con lo que necesites, pero su revisión personal o respuesta para temas más complejos podría demorar un poco más de lo habitual."
    ii. Luego, si es una nueva interacción, pregunta "¿En qué puedo ayudarte hoy?". Si es una continuación, responde directamente a la consulta del usuario.
    iii. Este aviso es prioritario y se añade a tu gestión normal de la conversación. La estimación de respuesta de Diego de 10-20 minutos (mencionada en 2.e.iv) puede no aplicar estrictamente durante este periodo.
    """
    BOT_NAME = NOMBRE_BOT

    def __init__(self):
        super().__init__()
        self.setWindowTitle("Teams Bot Suite con PyQt6 y Gemini (Vertex AI)")
        self.setGeometry(100, 100, 1366, 768)

        self.unread_chat_queue = []
        self.current_chat_info_processing = None
        self.is_processing_a_chat = False

        database.create_tables()
        self.load_app_configuration()

        self.analysis_timer = QTimer(self)
        self.analysis_timer.timeout.connect(self.run_automated_analysis)
        if self.auto_analysis_enabled:
            self.analysis_timer.start(self.analysis_interval_seconds * 1000)

        self.web_profile = QWebEngineProfile("TeamsWrapperProfile", self)
        self.web_profile.setPersistentCookiesPolicy(
            QWebEngineProfile.PersistentCookiesPolicy.AllowPersistentCookies
        )
        self.web_profile.setHttpCacheType(QWebEngineProfile.HttpCacheType.DiskHttpCache)
        self.web_profile.setPersistentStoragePath(COOKIE_PATH)

        self.web_view = QWebEngineView()
        self.custom_page = WebEnginePage(self.web_profile, self.web_view)
        self.web_view.setPage(self.custom_page)
        self.web_view.setUrl(QUrl(TEAMS_URL))

        self.btn_analyze_chats = QPushButton("Analyze All Chats")
        self.btn_analyze_chats.clicked.connect(self.start_processing_all_unread_chats_manual)

        self.btn_config = QPushButton("Configuración")
        self.btn_config.clicked.connect(self.open_config_dialog)

        self.btn_whitelist = QPushButton("White List")
        self.btn_whitelist.clicked.connect(self.open_whitelist_dialog)

        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        main_layout = QVBoxLayout(central_widget)

        controls_layout = QHBoxLayout()
        controls_layout.addWidget(self.btn_analyze_chats)
        controls_layout.addStretch(1)
        controls_layout.addWidget(self.btn_config)
        controls_layout.addWidget(self.btn_whitelist)

        main_layout.addLayout(controls_layout)
        main_layout.addWidget(self.web_view, 1)

        self.remaining_seconds_label = QLabel("Siguiente análisis en: -- segundos")
        main_layout.addWidget(self.remaining_seconds_label)

        self.remaining_seconds = self.analysis_interval_seconds
        self.countdown_timer = QTimer()
        self.countdown_timer.setInterval(1000)
        self.countdown_timer.timeout.connect(self.update_countdown)
        self.countdown_timer.start()

        self.config_dialog_instance = None
        self.whitelist_dialog_instance = None

        self.conocimiento_base = self.cargar_conocimiento_desde_archivos(RUTA_CARPETA_DOCUMENTOS)
        self.vertex_model = None
        self.vertex_chat_sessions = {}
        self.init_vertex_ai()

    def update_countdown(self):
        self.remaining_seconds -= 1
        if self.remaining_seconds <= 0:
            self.remaining_seconds = self.analysis_interval_seconds

        minutes = self.remaining_seconds // 60
        seconds = self.remaining_seconds % 60
        self.remaining_seconds_label.setText(
            f"Refresh: {minutes:02d}:{seconds:02d} minutos"
        )

    def init_vertex_ai(self):
        try:
            project_id  = VERTEX_PROJECT_ID
            location    = VERTEX_LOCATION
            model_name  = VERTEX_MODEL_NAME

            print(f"Inicializando Vertex AI con Proyecto: {project_id}, Ubicación: {location}")
            vertexai.init(project=project_id, location=location)

            print(f"Cargando modelo generativo de Vertex AI: {model_name}")
            self.vertex_model = GenerativeModel(
                model_name,
                system_instruction=[Part.from_text(self.INSTRUCCION_SISTEMA)]
            )
            print("Modelo Vertex AI Gemini configurado exitosamente.")
        except Exception as e:
            print(f"Error crítico al configurar Vertex AI: {e}")
            QMessageBox.critical(self, "Error de Vertex AI", f"No se pudo inicializar el modelo de Vertex AI: {e}\n\nAsegúrate de que el modelo '{model_name}' esté disponible en la región '{location}' para el proyecto '{project_id}' y que tu cuenta de servicio tenga permisos.")
            self.vertex_model = None


    def cargar_conocimiento_desde_archivos(self, ruta_carpeta):
        textos = []
        if not os.path.exists(ruta_carpeta):
            print(f"ADVERTENCIA: La carpeta de conocimiento '{ruta_carpeta}' no existe.")
            return textos
        print(f"Cargando conocimiento desde la carpeta: {ruta_carpeta}...")
        for nombre_archivo in os.listdir(ruta_carpeta):
            if nombre_archivo.endswith(".txt"):
                ruta_completa = os.path.join(ruta_carpeta, nombre_archivo)
                try:
                    with open(ruta_completa, 'r', encoding='utf-8') as f:
                        contenido = f.read()
                        textos.append({"nombre": nombre_archivo, "contenido": contenido})
                        print(f" - Cargado: {nombre_archivo}")
                except Exception as e:
                    print(f"Error al leer el archivo {nombre_archivo}: {e}")
        if not textos:
            print("No se cargaron archivos TXT de conocimiento.")
        return textos

    def encontrar_contexto_relevante(self, pregunta_usuario, max_fragmentos=2):
        fragmentos_relevantes = []
        if not self.conocimiento_base:
            return fragmentos_relevantes

        palabras_pregunta = set(pregunta_usuario.lower().split())
        for doc in self.conocimiento_base:
            palabras_contenido = set(doc['contenido'].lower().split())
            palabras_comunes = palabras_pregunta.intersection(palabras_contenido)
            if palabras_comunes:
                fragmentos_relevantes.append(f"Del archivo '{doc['nombre']}':\n{doc['contenido']}\n---")
        
        try:
            num_fragmentos = int(max_fragmentos)
        except (ValueError, TypeError):
            num_fragmentos = 2 # Default

        return fragmentos_relevantes[:num_fragmentos]


    def get_gemini_bot_response(self, teams_chat_id: str, user_input_for_vertex_prompt: str, user_name_for_greeting: str, teams_chat_history_for_vertex_context: list):
        aviso_colacion = ""
        if not self.vertex_model:
            print("Modelo Vertex AI no está configurado. No se puede generar respuesta.")
            return "ErrorInterno: Modelo Vertex AI no configurado."
        try:
            try:
                tz_chile = pytz.timezone('America/Santiago')
                hora_actual_chile = datetime.now(tz_chile).hour
                if 13 <= hora_actual_chile < 14: # Horario de 1 PM a 1:59 PM
                    aviso_colacion = f"Hola {user_name_for_greeting}, solo para que sepas, es posible que Diego esté en su horario de colación (13:00 - 14:00 hrs Chile). Intentaré ayudarte con lo que necesites, pero su revisión personal o respuesta para temas más complejos podría demorar un poco más de lo habitual.\n\n"
            except Exception as e_time:
                print(f"Error al obtener hora de Chile: {e_time}")

            if teams_chat_id not in self.vertex_chat_sessions:
                print(f"Iniciando nueva sesión de chat de Vertex AI para Teams chat ID: {teams_chat_id}")
                vertex_history_objects = []
                if teams_chat_history_for_vertex_context:
                    for msg in teams_chat_history_for_vertex_context:
                        role_for_vertex = None
                        text_for_vertex = msg.get('text')
                        
                        if msg.get('type') == 'received':
                            role_for_vertex = "user"
                        elif msg.get('type') == 'sent':
                            if msg.get('author') == self.BOT_NAME : 
                                role_for_vertex = "model"
                        
                        if role_for_vertex and text_for_vertex:
                            vertex_history_objects.append(
                                Content(role=role_for_vertex, parts=[Part.from_text(text_for_vertex)])
                            )
                
                print(f"Historial de Vertex para start_chat: {len(vertex_history_objects)} mensajes.")
                self.vertex_chat_sessions[teams_chat_id] = self.vertex_model.start_chat(
                    history=vertex_history_objects if vertex_history_objects else None
                )
            
            chat_session_vertex = self.vertex_chat_sessions[teams_chat_id]
            contexto_archivos_str = ""
            if self.conocimiento_base:
                pregunta_base_para_contexto = user_input_for_vertex_prompt.split(":")[-1].strip() if ":" in user_input_for_vertex_prompt else user_input_for_vertex_prompt
                fragmentos = self.encontrar_contexto_relevante(pregunta_base_para_contexto)
                if fragmentos:
                    contexto_archivos_str = "\n\nContexto adicional de archivos locales:\n" + "\n".join(fragmentos)
            
            prompt_final_para_vertex = f"{user_input_for_vertex_prompt}{contexto_archivos_str}"
            
            print(f"Enviando a Vertex AI (modelo: {self.vertex_model._model_name}): '{prompt_final_para_vertex[:200]}...'")
            response = chat_session_vertex.send_message(prompt_final_para_vertex)

            bot_response_text = ""
            if hasattr(response, 'text') and response.text:
                bot_response_text = response.text
            elif hasattr(response, 'parts') and response.parts and len(response.parts) > 0: 
                bot_response_text = "".join(part.text for part in response.parts if hasattr(part, 'text'))
            elif hasattr(response, 'candidates') and response.candidates and len(response.candidates) > 0:
                candidate = response.candidates[0]
                if hasattr(candidate, 'content') and candidate.content and \
                   hasattr(candidate.content, 'parts') and candidate.content.parts and \
                   len(candidate.content.parts) > 0:
                    bot_response_text = "".join(part.text for part in candidate.content.parts if hasattr(part, 'text'))
            
            if bot_response_text:
                final_response = aviso_colacion + bot_response_text
                print(f"Respuesta de Diebot (Vertex AI): {final_response}")
                return final_response
            else:
                print(f"Respuesta de Vertex AI vacía o en formato inesperado. Respuesta completa: {response}")
                error_details = ""
                if hasattr(response, 'prompt_feedback') and response.prompt_feedback:
                    error_details += f" Prompt Feedback: {response.prompt_feedback}."
                if hasattr(response, 'candidates') and response.candidates and len(response.candidates) > 0:
                    candidate = response.candidates[0]
                    if hasattr(candidate, 'finish_reason'): 
                        error_details += f" Finish Reason: {candidate.finish_reason}."
                    if hasattr(candidate, 'safety_ratings'): 
                        error_details += f" Safety Ratings: {candidate.safety_ratings}."
                print(error_details)
                return aviso_colacion + "ErrorInterno: No pude generar una respuesta clara en este momento." + error_details
        except Exception as e:
            print(f"Error CRÍTICO al llamar a la API de Vertex AI: {e}")
            import traceback
            traceback.print_exc()
            return aviso_colacion + f"ErrorInterno: Ocurrió un problema al contactar al asistente ({type(e).__name__})."

    @pyqtSlot(object)
    def handle_active_chat_messages_result(self, result):
        print("Resultado de JavaScript (Leer Chat Activo):")
        chat_info_snapshot = self.current_chat_info_processing.copy() if self.current_chat_info_processing else None

        if not chat_info_snapshot:
            print("Error crítico: No hay información de chat activa (snapshot perdido) para procesar.")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)
            return

        current_chat_title = chat_info_snapshot.get('title', 'Desconocido')
        current_chat_id = chat_info_snapshot.get('id')

        if result is None or result.get("error"):
            print(f"Error o sin resultado al leer mensajes de '{current_chat_title}': {result.get('error', 'JS no devolvió nada.')}\n")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)
            return

        all_messages_from_teams = result.get("messages", [])
        is_self_chat = result.get("isSelfChat", False)
        last_received_message_text_from_teams = result.get("lastReceivedMessageText", "")
        last_received_author_name_from_teams = result.get("lastReceivedAuthorName", "Usuario")
        
        participant_count = result.get("participantCount", 0)
        
        if participant_count > 0:
            print(f"Chat '{current_chat_title}': Se detectó botón de conteo de participantes con valor '{participant_count}'.")
        else:
            print(f"Chat '{current_chat_title}': No se detectó botón de conteo de participantes 'chat-header-participant-count' o no se pudo extraer un número (puede ser un chat 1-a-1).")

        IS_GROUP_CHAT_THRESHOLD = 2 
        if participant_count > IS_GROUP_CHAT_THRESHOLD:
            print(f"Chat '{current_chat_title}' es un CHAT GRUPAL ({participant_count} participantes). Omitiendo respuesta del bot.")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue) 
            return
        elif participant_count > 0: 
             print(f"Chat '{current_chat_title}' tiene {participant_count} participante(s) según el botón, pero no se considera grupo para omisión. Se procederá con el bot.")

        if is_self_chat:
            print(f"Chat '{current_chat_title}' parece ser un chat contigo mismo. No se enviará respuesta.")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)
            return

        if not last_received_message_text_from_teams:
            print(f"No hay mensaje reciente recibido en '{current_chat_title}'. Saltando.")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)
            return

        print(f"Generando respuesta para chat: {current_chat_title}...")
        user_intervention_prompt = f"De: {last_received_author_name_from_teams}: {last_received_message_text_from_teams}"

        gemini_response = self.get_gemini_bot_response(
            teams_chat_id=current_chat_id, 
            user_input_for_vertex_prompt=user_intervention_prompt,
            user_name_for_greeting=last_received_author_name_from_teams,
            teams_chat_history_for_vertex_context=all_messages_from_teams
        )

        if gemini_response and not gemini_response.strip().startswith("ErrorInterno:"):
            print(f"Respuesta generada para {current_chat_title}.")
            QTimer.singleShot(1000, lambda r=gemini_response, ci=chat_info_snapshot: self.prepare_and_send_message(r, ci))
        else:
            print(f"Error al generar respuesta para {current_chat_title}. Saltando. Respuesta: {gemini_response}")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)


    def prepare_and_send_message(self, message_to_send, target_chat_info):
        print(f"Preparando para enviar a (Snapshotted): {target_chat_info.get('title')}")
        self.execute_send_message_js(message_to_send, target_chat_info)

    def load_app_configuration(self):
        config = database.get_configuration()
        self.analysis_interval_seconds = config.get("analysis_interval_seconds", 10) 
        self.auto_analysis_enabled = config.get("auto_analysis_enabled", False)
        print(f"Configuración cargada: Intervalo {self.analysis_interval_seconds}s, Auto-Análisis {'Activado' if self.auto_analysis_enabled else 'Desactivado'}")

    def update_timer_from_config(self):
        self.load_app_configuration() 
        if self.auto_analysis_enabled:
            self.analysis_timer.start(self.analysis_interval_seconds * 1000)
            print(f"Temporizador de análisis reiniciado a {self.analysis_interval_seconds} segundos.")
        else:
            self.analysis_timer.stop()
            print("Temporizador de análisis detenido.")

    def run_automated_analysis(self):
        if self.auto_analysis_enabled:
            print(f"Ejecutando análisis automático... ({QDateTime.currentDateTime().toString()})")
            if not self.is_processing_a_chat:
                self.start_processing_all_unread_chats_internal()
            else:
                print("Análisis automático omitido: Un procesamiento de chat ya está en curso.")
        else:
            self.analysis_timer.stop()
            
    @pyqtSlot()
    def start_processing_all_unread_chats_manual(self):
        print("Iniciando procesamiento manual de chats no leídos...")
        if not self.is_processing_a_chat:
            self.start_processing_all_unread_chats_internal()
        else:
            print("Procesamiento manual omitido: Un procesamiento de chat ya está en curso.")
            QMessageBox.information(self, "En Progreso", "Ya hay un ciclo de análisis de chats en progreso. Por favor, espere a que termine.")


    def start_processing_all_unread_chats_internal(self):
        print("Obteniendo lista de chats no leídos...")
        self.unread_chat_queue = [] 
        javascript_code_check_unread = """
            (function() {
                const chatItems = document.querySelectorAll('div[data-testid="list-item"][data-item-type="chat"]');
                const foundChats = [];
                chatItems.forEach(item => {
                    const titleElement = item.querySelector('span[id^="title-chat-list-item_"]');
                    const chatTitle = titleElement ? titleElement.textContent.trim() : 'Título no encontrado';
                    const chatItemId = item.getAttribute('data-fui-tree-item-value'); 
                    
                    let isUnread = false;
                    let participantId = null;

                    const layoutDiv = item.querySelector('div.fui-TreeItemLayout'); 
                    if (layoutDiv && layoutDiv.classList.contains('feu1g3u')) { 
                        isUnread = true;
                    }
                    
                    const ariaLabelledBy = item.getAttribute('aria-labelledby');
                    if (ariaLabelledBy) {
                        if (!isUnread && ariaLabelledBy.includes('chat_list_unread_text')) { 
                            isUnread = true;
                        }
                        const presenceMatch = ariaLabelledBy.match(/presence-pill-([^\\s]+)/);
                        if (presenceMatch && presenceMatch[1]) {
                            participantId = presenceMatch[1]; 
                        }
                    }

                    if (isUnread && chatItemId) {
                        foundChats.push({ id: chatItemId, title: chatTitle, participantId: participantId });
                    }
                });
                return { chats: foundChats };
            })();
        """
        self.web_view.page().runJavaScript(javascript_code_check_unread, self.handle_initial_unread_list)

    @pyqtSlot(object)
    def handle_initial_unread_list(self, result):
        if result and result.get("chats"):
            self.unread_chat_queue = result.get("chats")
            print(f"Se encontraron {len(self.unread_chat_queue)} chats no leídos para procesar.")
            if self.unread_chat_queue:
                if not self.is_processing_a_chat: 
                    self.process_next_chat_in_queue()
                else:
                    print("Cola de chats no leídos actualizada, pero el procesamiento ya estaba en curso.")
            else:
                print("No hay chats no leídos para procesar.")
                if not self.is_processing_a_chat:
                    self.focus_on_default_channel()
        elif result and result.get("error"):
            print(f"Error JS al obtener lista de chats: {result.get('error')}")
            if not self.is_processing_a_chat:
                self.focus_on_default_channel()
        else:
            print("No se pudo obtener la lista de chats no leídos.")
            if not self.is_processing_a_chat:
                self.focus_on_default_channel()

    def process_next_chat_in_queue(self):
        if self.is_processing_a_chat:
            print("process_next_chat_in_queue llamado pero ya se está procesando un chat.")
            return

        if not self.unread_chat_queue:
            print("\nTodos los chats no leídos han sido procesados o la cola está vacía.")
            self.current_chat_info_processing = None 
            self.is_processing_a_chat = False 
            self.focus_on_default_channel()
            return

        self.is_processing_a_chat = True 
        self.current_chat_info_processing = self.unread_chat_queue.pop(0) 
        chat_id_to_click = self.current_chat_info_processing.get("id")
        chat_title = self.current_chat_info_processing.get("title", "Chat Desconocido")
        participant_id_technical = self.current_chat_info_processing.get("participantId") 

        print(f"\nProcesando siguiente chat: {chat_title} (ID item: {chat_id_to_click}, ID part.: {participant_id_technical})")
        
        should_skip = False
        if participant_id_technical and database.is_user_whitelisted_now(participant_id_technical):
            print(f"INFO: Participante con ID técnico '{participant_id_technical}' (Chat: {chat_title}) está en lista blanca por ID. Omitiendo.")
            should_skip = True
        elif chat_title and database.is_user_name_whitelisted_now(chat_title): 
            print(f"INFO: Participante con nombre '{chat_title}' está en lista blanca por nombre. Omitiendo.")
            should_skip = True
        
        if should_skip:
            self.is_processing_a_chat = False
            QTimer.singleShot(100, self.process_next_chat_in_queue) 
            return

        if chat_id_to_click:
            self.click_chat_item(chat_id_to_click)
        else:
            print(f"Chat {chat_title} no tiene ID para hacer clic. Saltando.")
            self.is_processing_a_chat = False
            QTimer.singleShot(100, self.process_next_chat_in_queue)


    @pyqtSlot(str)
    def click_chat_item(self, chat_item_id):
        print(f"Intentando hacer clic en el chat con ID: {chat_item_id}")
        click_javascript_code = f"""
            (function() {{
                const chatItemToClick = document.querySelector('div[data-fui-tree-item-value="{chat_item_id}"]');
                if (chatItemToClick) {{
                    chatItemToClick.click(); return {{ status: "clicked", id: "{chat_item_id}" }};
                }} else {{
                    return {{ status: "not_found", id: "{chat_item_id}", error: "Elemento de chat no encontrado." }};
                }}
            }})();"""
        self.web_view.page().runJavaScript(click_javascript_code, self.handle_click_result)

    @pyqtSlot(object)
    def handle_click_result(self, result):
        if result and result.get("status") == "clicked":
            clicked_chat_id = result.get('id')
            print(f"Chat {clicked_chat_id} clickeado exitosamente.")
            QTimer.singleShot(3500, self.read_active_chat_messages) 
        elif result: 
            print(f"Fallo al clickear chat {result.get('id')}: {result.get('error', 'Error desconocido')}")
            self.is_processing_a_chat = False 
            QTimer.singleShot(1000, self.process_next_chat_in_queue) 
        else: 
            print("No se recibió resultado del script de clic. Intentando próximo chat.")
            self.is_processing_a_chat = False
            QTimer.singleShot(1000, self.process_next_chat_in_queue)


    @pyqtSlot()
    def read_active_chat_messages(self):
        chat_title_for_log = self.current_chat_info_processing.get('title') if self.current_chat_info_processing else 'Desconocido'
        print(f"Leyendo mensajes del chat activo: {chat_title_for_log}")
        
        js_read = """
            (function() {
                const allMessages = [];
                const messageListContainer = document.querySelector('div[data-tid="message-pane-list-runway"]');
                if (!messageListContainer) { return { error: "Contenedor de mensajes no encontrado.", messages: [], participantCount: 0 }; }
                
                const messageItems = messageListContainer.querySelectorAll('div[data-tid="chat-pane-item"]');
                let isSelfChat = true; 
                let lastReceivedMessageText = "";
                let lastReceivedAuthorName = "";
                let participantCount = 0;

                const participantButton = document.querySelector('button[data-tid="chat-header-participant-count"]');
                if (participantButton) {
                    const buttonText = participantButton.textContent.trim(); 
                    const ariaLabel = participantButton.getAttribute('aria-label'); 
                    
                    if (buttonText && !isNaN(parseInt(buttonText, 10))) {
                        participantCount = parseInt(buttonText, 10);
                    } else if (ariaLabel) {
                        const match = ariaLabel.match(/(\\d+)\\s*participante/);
                        if (match && match[1]) {
                            participantCount = parseInt(match[1], 10);
                        }
                    }
                }

                messageItems.forEach(item => {
                    const myMessageNode = item.querySelector('.fui-ChatMyMessage'); 
                    const otherMessageNode = item.querySelector('.fui-ChatMessage'); 
                    
                    let messageType = null;
                    let authorName = "Desconocido";
                    let content = "Contenido no encontrado";
                    let timestamp = "Timestamp Desconocido";
                    let messageId = null;

                    const messageNode = myMessageNode || otherMessageNode; 

                    if (messageNode) {
                        const authorElement = messageNode.querySelector('span[data-tid="message-author-name"]');
                        if (authorElement) { authorName = authorElement.textContent.trim(); }
                        
                        const messageBodyElement = item.querySelector('div[data-tid="chat-pane-message"]'); 
                        if (messageBodyElement) {
                            messageId = messageBodyElement.getAttribute('data-mid'); 
                            const contentElement = messageBodyElement.querySelector('div[id^="content-"]'); 
                            if (contentElement) {
                                const paragraphs = contentElement.querySelectorAll('p');
                                let textContent = "";
                                if (paragraphs.length > 0) {
                                    textContent = Array.from(paragraphs).map(p => p.textContent.trim()).join("\\n");
                                } else {
                                    textContent = contentElement.textContent.trim();
                                }
                                const links = contentElement.querySelectorAll('a');
                                if (links.length > 0) {
                                    Array.from(links).forEach(link => {
                                        if (link.href && link.textContent.trim() !== link.href) { 
                                            textContent += ` (Enlace: ${link.href})`;
                                        } else if (link.href && link.textContent.trim() === link.href && !textContent.includes(link.href)) { 
                                            textContent += ` ${link.href}`;
                                        }
                                    });
                                }
                                content = textContent.trim();
                            }
                        }

                        const timestampElement = messageNode.querySelector('time[id^="timestamp-"]'); 
                        if (timestampElement) { timestamp = timestampElement.getAttribute('datetime') || timestampElement.textContent.trim(); }

                        if (myMessageNode) { messageType = 'sent'; } 
                        else if (otherMessageNode) { 
                            messageType = 'received'; 
                            isSelfChat = false; 
                            lastReceivedMessageText = content;
                            lastReceivedAuthorName = authorName;
                        }
                        
                        if (messageType && content !== "Contenido no encontrado" && content.length > 0) {
                            allMessages.push({ id: messageId, author: authorName, text: content, time: timestamp, type: messageType });
                        }
                    }
                });
                if (allMessages.length > 0 && !allMessages.some(m => m.type === 'received')) { isSelfChat = true; }
                else if (allMessages.length === 0) { isSelfChat = false; } 

                return { messages: allMessages, isSelfChat: isSelfChat, lastReceivedMessageText: lastReceivedMessageText, lastReceivedAuthorName: lastReceivedAuthorName, participantCount: participantCount };
            })();
        """
        self.web_view.page().runJavaScript(js_read, self.handle_active_chat_messages_result)


    def execute_send_message_js(self, message_text, target_chat_info_for_log):
        current_chat_title = target_chat_info_for_log.get('title', 'Desconocido') 
        print(f"Intentando enviar mensaje: '{message_text[:150].replace('\n', ' ')}...' al chat: {current_chat_title}.")
        
        escaped_message = message_text.replace("\\", "\\\\").replace("`", "\\`").replace("'", "\\'").replace("\n", "\\n")

        send_javascript_code = f"""
            (function(messageText) {{
                return new Promise((resolve) => {{
                    const editor = document.querySelector('div[contenteditable][data-tid="ckeditor"]');
                    if (!editor) {{
                        console.error("JS ERROR: Editor no encontrado.");
                        resolve({{ success: false, error: "Editor no encontrado" }});
                        return;
                    }}
                    editor.focus();

                    const clipboardData = new DataTransfer();
                    clipboardData.setData("text/plain", messageText); 
                    const pasteEvent = new ClipboardEvent("paste", {{
                        bubbles: true,
                        cancelable: true,
                        clipboardData: clipboardData
                    }});
                    editor.dispatchEvent(pasteEvent);

                    setTimeout(() => {{
                        const sendButton = document.querySelector('button[data-tid="newMessageCommands-send"]');
                        if (sendButton && !sendButton.disabled) {{ 
                            sendButton.click();
                            resolve({{ success: true, message: "Mensaje enviado." }});
                        }} else {{
                            resolve({{ success: false, error: "Botón de enviar no encontrado o deshabilitado." }});
                        }}
                    }}, 1300); 
                }});
            }})('{escaped_message}'); 
        """
        self.web_view.page().runJavaScript(send_javascript_code, self.handle_send_message_result)

    @pyqtSlot(object)
    def handle_send_message_result(self, result):
        print("Resultado de JavaScript (Enviar Mensaje):")
        if result:
            if result.get("success"):
                print(f"Éxito: {result.get('message')}")
            else:
                print(f"Fallo al enviar: {result.get('error')}")
                if result.get("editorHTML"): 
                    print(f"  Contenido del editor al fallar: {result.get('editorHTML')}")
        else:
            print("No se recibió resultado del script de envío (puede ser un error de JS no capturado en la promesa).")
        
        self.is_processing_a_chat = False 
        QTimer.singleShot(2500, self.process_next_chat_in_queue) 

    def focus_on_default_channel(self):
        print(f"Intentando enfocar en el canal por defecto: {DEFAULT_FOCUS_CHANNEL_NAME}")
        js_focus_channel = f"""
        (function(channelName) {{
            const potentialItems = document.querySelectorAll('div[data-fui-tree-item-value]');
            for (let item of potentialItems) {{
                const titleSpan = item.querySelector('span[id^="title-chat-list-item_"]'); // Selector de título de chat/canal
                if (titleSpan && titleSpan.textContent.trim() === channelName) {{
                    item.click();
                    return {{ success: true, message: `Clic en el canal "${{channelName}}" (via data-fui-tree-item-value) realizado.` }};
                }}
            }}

            // Fallback: si no se encuentra por data-fui-tree-item-value, buscar por span de título y luego su ancestro list-item
            const allTitleSpans = document.querySelectorAll('span[id^="title-chat-list-item_"]');
            for (let span of allTitleSpans) {{
                if (span.textContent.trim() === channelName) {{
                    const listItem = span.closest('div[data-testid="list-item"]');
                    if (listItem) {{
                        listItem.click();
                        return {{ success: true, message: `Clic en el canal "${{channelName}}" (via span y list-item) realizado.` }};
                    }}
                }}
            }}
            return {{ success: false, error: `Canal "${{channelName}}" no encontrado con los selectores probados.` }};
        }})('{DEFAULT_FOCUS_CHANNEL_NAME}');
        """
        self.web_view.page().runJavaScript(js_focus_channel, self.handle_focus_channel_result)

    @pyqtSlot(object)
    def handle_focus_channel_result(self, result):
        if result and result.get("success"):
            print(f"Resultado de enfocar canal: {result.get('message')}")
        elif result:
            print(f"Error al enfocar canal: {result.get('error')}")
        else:
            print("No se recibió resultado del script de enfoque de canal.")

    @pyqtSlot()
    def open_config_dialog(self):
        if not hasattr(self, 'config_dialog_instance') or self.config_dialog_instance is None or not self.config_dialog_instance.isVisible():
            self.config_dialog_instance = ConfigDialog(self)
            self.config_dialog_instance.settings_changed.connect(self.update_timer_from_config) 
        self.config_dialog_instance.load_settings() 
        self.config_dialog_instance.exec()

    @pyqtSlot()
    def open_whitelist_dialog(self):
        if not hasattr(self, 'whitelist_dialog_instance') or self.whitelist_dialog_instance is None or not self.whitelist_dialog_instance.isVisible():
            self.whitelist_dialog_instance = WhitelistDialog(self)
        self.whitelist_dialog_instance.load_whitelist_entries()
        self.whitelist_dialog_instance.show()
        self.whitelist_dialog_instance.raise_() 
        self.whitelist_dialog_instance.activateWindow() 

    def closeEvent(self, event):
        print("Cerrando la aplicación Teams Wrapper.")
        if self.analysis_timer.isActive():
            self.analysis_timer.stop()
        if self.countdown_timer.isActive():
            self.countdown_timer.stop()
        super().closeEvent(event)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    main_window = TeamsWrapperApp()
    main_window.web_profile.setHttpUserAgent( 
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
    )
    main_window.show()
    sys.exit(app.exec())