Update app.py

app.py

@@ -1,3 +1,6 @@
+# app.py - MateAI v18.3: Conciencia Aumentada
+# Arquitectura por un asistente de IA para un futuro colaborativo.
+
 import gradio as gr
 import random
 import time
@@ -5,322 +8,535 @@ import json
 from datetime import datetime, timedelta
 import os
 import asyncio
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+
+# --- LIBRERÍAS DE IA Y NLP ---
+# Usaremos pysentimiento para un análisis de sentimiento robusto en español.
+from pysentimiento import create_analyzer
 
-# --- Firebase Admin SDK Imports ---
+# --- INTEGRACIÓN CON FIREBASE ---
+# Firebase se usará como nuestro "núcleo de memoria" persistente.
 import firebase_admin
 from firebase_admin import credentials, firestore
 
-# --- MÓDULO 1: CONFIGURACIÓN Y CONSTANTES (REFORZADO) ---
+# ==============================================================================
+# MÓDULO 1: CONFIGURACIÓN Y CONSTANTES DEL SISTEMA
+# ==============================================================================
+# Define el comportamiento global, los límites y las constantes de la aplicación.
+# Es la "constitución" de MateAI.
+# ==============================================================================
+
 class Config:
-    APP_NAME = "MateAI: El Super Agente Argentino"
-    # PLANO MAESTRO DE PREFERENCIAS: Nuestra fuente única de verdad.
-    DEFAULT_USER_PREFS = {
-        "tipo_susurro": "ambos", 
-        "frecuencia": "normal", 
-        "modo_che_tranqui": False, 
-        "voice_uri": "default"
+    """Clase de configuración central para todos los parámetros de MateAI."""
+    APP_NAME = "MateAI v18.3: Conciencia Aumentada"
+    APP_VERSION = "18.3.0-alpha"
+    
+    # --- Configuración de Base de Datos ---
+    FIREBASE_COLLECTION_USERS = "users_v18" # Nueva colección para la arquitectura avanzada.
+    
+    # --- Parámetros del Motor de Personalidad (Basado en el Modelo OCEAN) ---
+    # Estos son los valores iniciales para un nuevo usuario.
+    # El rango de cada rasgo es de -1.0 (bajo) a 1.0 (alto).
+    DEFAULT_PSYCH_PROFILE = {
+        "openness": 0.0,          # Apertura a nuevas experiencias
+        "conscientiousness": 0.0, # Organización y responsabilidad
+        "extraversion": 0.0,      # Sociabilidad y energía
+        "agreeableness": 0.0,     # Amabilidad y cooperación
+        "neuroticism": 0.0,       # Estabilidad emocional (inversa)
     }
-    ECO_PUNTOS_POR_SUSURRO = 1
-    MAX_HISTORIAL_SUSURROS = 50
-    NUDGE_COOLDOWN_MINUTES = 0.5
-    TASK_NUDGE_COOLDOWN_HOURS = 4
-    FIREBASE_COLLECTION_USERS = "users_v2" 
+    
+    # --- Parámetros del Motor de Gamificación ---
+    POINTS_PER_INSIGHT = 10       # Puntos por una reflexión profunda.
+    POINTS_PER_GOAL_COMPLETED = 25# Puntos por completar una meta a largo plazo.
+    POINTS_PER_FEEDBACK = 5       # Puntos por dar feedback a MateAI.
+    
+    # --- Parámetros del Motor de Interacción ---
+    PROACTIVE_CHECKIN_HOURS = 6   # Horas antes de que MateAI considere un "check-in".
+    MAX_MEMORY_STREAM_ITEMS = 200 # Límite de recuerdos para no sobrecargar el perfil.
+    SENTIMENT_THRESHOLD_NEGATIVE = -0.3 # Umbral para detectar sentimiento negativo.
+    SENTIMENT_THRESHOLD_POSITIVE = 0.3 # Umbral para detectar sentimiento positivo.
 
-# --- INICIALIZACIÓN DE FIREBASE ---
+# ==============================================================================
+# MÓDULO 2: INICIALIZACIÓN DE SERVICIOS EXTERNOS
+# ==============================================================================
+# Conexión a la base de datos y carga de modelos de IA.
+# Este bloque se ejecuta una sola vez al iniciar la aplicación.
+# ==============================================================================
+
+# --- Configuración de Logging ---
+# Un buen logging es crucial para depurar un sistema complejo.
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- Inicialización del Analizador de Sentimiento ---
+# Cargamos el modelo una vez para no recargarlo en cada request.
+try:
+    sentiment_analyzer = create_analyzer(task="sentiment", lang="es")
+    logging.info("Analizador de sentimiento cargado exitosamente.")
+except Exception as e:
+    sentiment_analyzer = None
+    logging.error(f"No se pudo cargar el analizador de sentimiento: {e}")
+
+# --- Inicialización de Firebase Admin SDK ---
+db = None
 try:
     if not firebase_admin._apps:
         firebase_credentials_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
         if firebase_credentials_json:
             cred_dict = json.loads(firebase_credentials_json)
+            # Aseguramos el project_id si no está en el JSON (común en algunos entornos)
             if 'project_id' not in cred_dict:
-                cred_dict['project_id'] = 'mateai-815ca'
+                cred_dict['project_id'] = 'mateai-815ca' # Reemplazar con tu project_id real si es diferente
             cred = credentials.Certificate(cred_dict)
             firebase_admin.initialize_app(cred)
-            print("Firebase Admin SDK inicializado correctamente.")
+            db = firestore.client()
+            logging.info("Firebase Admin SDK inicializado correctamente. Conexión a Firestore establecida.")
         else:
-            print("ADVERTENCIA: GOOGLE_APPLICATION_CREDENTIALS_JSON no está configurada. La persistencia de datos NO funcionará.")
+            logging.warning("SECRET 'GOOGLE_APPLICATION_CREDENTIALS_JSON' no configurado. La persistencia de datos NO funcionará.")
+    else:
+        db = firestore.client()
+        logging.info("Firebase Admin SDK ya estaba inicializado.")
 except Exception as e:
-    if "The default Firebase app already exists" not in str(e):
-        print(f"Error al inicializar Firebase: {e}")
+    logging.error(f"Error CRÍTICO al inicializar Firebase: {e}")
 
-db = firestore.client() if firebase_admin._apps else None
+# ==============================================================================
+# MÓDULO 3: MODELOS DE DATOS Y CLASES CENTRALES
+# ==============================================================================
+# Definen la estructura de los datos con los que operamos. La clase User
+# es el corazón del sistema, representando el estado completo de un individuo.
+# ==============================================================================
 
-# --- MODELOS DE DATOS Y LÓGICA DE NEGOCIO ---
-# --- (Omitidos por brevedad, son idénticos a los de la versión anterior. Se pegarán abajo para tener el script completo) ---
-
-# --- MODELOS DE DATOS Y LÓGICA DE NEGOCIO ---
 class User:
-    def __init__(self, user_id, name, preferences, eco_points=0, nudge_history=None, last_oracle_date_str=None, last_nudge_time_str=None, tasks=None):
-        self.user_id = user_id
-        self.name = name
-        # Garantiza que las preferencias siempre estén completas usando el plano de Config
-        self.preferences = Config.DEFAULT_USER_PREFS.copy()
-        if preferences:
-            self.preferences.update(preferences)
-        self.eco_points = eco_points
-        self.nudge_history = nudge_history if nudge_history is not None else []
-        self.tasks = tasks if tasks is not None else []
-        self.last_oracle_date = datetime.strptime(last_oracle_date_str, '%Y-%m-%d').date() if last_oracle_date_str else None
-        self.last_nudge_time = datetime.strptime(last_nudge_time_str, '%Y-%m-%d %H:%M:%S.%f') if last_nudge_time_str else None
-        self.nudge_cooldown = timedelta(minutes=Config.NUDGE_COOLDOWN_MINUTES)
+    """Representa el estado completo de un usuario, incluyendo su personalidad y memoria."""
+    def __init__(self, user_id: str, name: str, **kwargs: Any):
+        self.user_id: str = user_id
+        self.name: str = name
+        self.created_at: datetime = kwargs.get('created_at', datetime.now())
+        self.last_login: datetime = kwargs.get('last_login', datetime.now())
+        
+        # El perfil psicológico, la joya de la corona.
+        self.psych_profile: Dict[str, float] = kwargs.get('psych_profile', Config.DEFAULT_PSYCH_PROFILE.copy())
+        
+        # Memoria a corto y largo plazo.
+        self.memory_stream: List[Dict[str, Any]] = kwargs.get('memory_stream', [])
+        self.short_term_context: Dict[str, Any] = {} # No se persiste, es para la sesión actual.
+        
+        # Sistema de metas, reemplaza a las simples "tareas".
+        self.goals: List[Dict[str, Any]] = kwargs.get('goals', [])
         
-    def to_dict(self):
+        # Gamificación con propósito.
+        self.connection_points: int = kwargs.get('connection_points', 0)
+        self.achievements: List[str] = kwargs.get('achievements', [])
+        
+        # Metadata para la proactividad.
+        self.last_proactive_checkin: Optional[datetime] = kwargs.get('last_proactive_checkin')
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serializa el objeto User a un diccionario para guardarlo en Firestore."""
         return {
-            "user_id": self.user_id, "name": self.name, "preferences": self.preferences, "eco_points": self.eco_points,
-            "nudge_history": self.nudge_history, "tasks": self.tasks,
-            "last_oracle_date": self.last_oracle_date.strftime('%Y-%m-%d') if self.last_oracle_date else None,
-            "last_nudge_time": self.last_nudge_time.strftime('%Y-%m-%d %H:%M:%S.%f') if self.last_nudge_time else None,
+            "user_id": self.user_id,
+            "name": self.name,
+            "created_at": self.created_at.isoformat(),
+            "last_login": self.last_login.isoformat(),
+            "psych_profile": self.psych_profile,
+            "memory_stream": self.memory_stream,
+            "goals": self.goals,
+            "connection_points": self.connection_points,
+            "achievements": self.achievements,
+            "last_proactive_checkin": self.last_proactive_checkin.isoformat() if self.last_proactive_checkin else None
         }
 
-class Nudge:
-    def __init__(self, text_template, type, context_tags, cultural_tags):
-        self.text_template, self.type, self.context_tags, self.cultural_tags = text_template, type, context_tags, cultural_tags
-
-class UserManager:
     @classmethod
-    async def create_user(cls, name, initial_prefs=None):
-        if not db: return None, "Error: La base de datos no está disponible."
-        user_id = f"user_{int(time.time())}_{random.randint(1000, 9999)}"
-        # SOLUCIÓN: Usar siempre el plano completo de preferencias
-        final_prefs = Config.DEFAULT_USER_PREFS.copy()
-        if initial_prefs:
-            final_prefs.update(initial_prefs)
-        new_user = User(user_id, name, final_prefs)
-        user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
-        try:
-            await asyncio.to_thread(user_doc_ref.set, new_user.to_dict())
-            return new_user, f"¡Bienvenido, {name}! Tu ID de usuario es: {user_id}."
-        except Exception as e:
-            return None, f"Error al crear usuario en Firestore: {e}"
+    def from_dict(cls, data: Dict[str, Any]) -> 'User':
+        """Crea una instancia de User a partir de un diccionario de Firestore."""
+        # Conversión de fechas de ISO string a datetime
+        data['created_at'] = datetime.fromisoformat(data.get('created_at', datetime.now().isoformat()))
+        data['last_login'] = datetime.fromisoformat(data.get('last_login', datetime.now().isoformat()))
+        last_checkin_str = data.get('last_proactive_checkin')
+        data['last_proactive_checkin'] = datetime.fromisoformat(last_checkin_str) if last_checkin_str else None
+        
+        # Aseguramos que el perfil psicológico tenga todas las claves
+        profile = Config.DEFAULT_PSYCH_PROFILE.copy()
+        profile.update(data.get('psych_profile', {}))
+        data['psych_profile'] = profile
 
-    @classmethod
-    async def login_user(cls, user_id):
-        if not db: return None, "Error: La base de datos no está disponible."
-        user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
+        return cls(**data)
+        
+    def add_memory(self, content: str, memory_type: str, sentiment: Dict[str, float], tags: List[str] = []):
+        """Añade un nuevo recuerdo al flujo de memoria del usuario."""
+        if len(self.memory_stream) >= Config.MAX_MEMORY_STREAM_ITEMS:
+            self.memory_stream.pop(0) # Mantiene el tamaño del flujo de memoria
+        
+        memory = {
+            "timestamp": datetime.now().isoformat(),
+            "content": content,
+            "type": memory_type, # 'chat', 'insight', 'goal_set', 'goal_completed'
+            "sentiment": sentiment,
+            "tags": tags
+        }
+        self.memory_stream.append(memory)
+        logging.info(f"Nuevo recuerdo añadido para {self.name}: {content[:50]}...")
+
+# ==============================================================================
+# MÓDULO 4: GESTOR DE DATOS DE USUARIO (CAPA DE PERSISTENCIA)
+# ==============================================================================
+# Abstrae toda la lógica de comunicación con Firestore. Permite cambiar
+# de base de datos en el futuro sin alterar el resto del código.
+# ==============================================================================
+
+class UserManager:
+    """Maneja la carga, creación y actualización de perfiles de usuario en Firestore."""
+    
+    @staticmethod
+    async def get_user(user_id: str) -> Optional[User]:
+        """Carga un usuario desde Firestore por su ID."""
+        if not db or not user_id: return None
         try:
+            user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
             doc = await asyncio.to_thread(user_doc_ref.get)
             if doc.exists:
                 user_data = doc.to_dict()
-                # SOLUCIÓN: Sanar datos antiguos al cargar.
-                final_prefs = Config.DEFAULT_USER_PREFS.copy()
-                db_prefs = user_data.get('preferences', {})
-                if db_prefs:
-                    final_prefs.update(db_prefs)
-                loaded_user = User(user_id=doc.id, name=user_data.get('name'), preferences=final_prefs, **user_data)
-                return loaded_user, f"Perfil de {loaded_user.name} cargado con éxito."
-            return None, "Error: ID de usuario no encontrado."
+                user_data['user_id'] = doc.id # Aseguramos que el ID esté en los datos.
+                
+                # Actualizar la fecha de último login y guardar inmediatamente.
+                user_obj = User.from_dict(user_data)
+                user_obj.last_login = datetime.now()
+                await UserManager.save_user(user_obj) # Guardado asíncrono
+                
+                logging.info(f"Usuario '{user_obj.name}' ({user_id}) cargado y actualizado.")
+                return user_obj
+            else:
+                logging.warning(f"Intento de carga de usuario inexistente: {user_id}")
+                return None
         except Exception as e:
-            return None, f"Error al cargar usuario desde Firestore: {e}"
-
-    # ... (El resto de UserManager, ContextEngine, NudgeGenerator, etc., son robustos y no necesitan cambios)
+            logging.error(f"Error al cargar usuario {user_id} desde Firestore: {e}")
+            return None
 
-class ContextEngine:
     @staticmethod
-    def get_current_time_context():
-        hora_actual = datetime.now().hour
-        if 6 <= hora_actual < 12: return "Mañana"
-        elif 12 <= hora_actual < 19: return "Mediodía/Tarde"
-        else: return "Noche"
+    async def create_user(name: str) -> Tuple[Optional[User], str]:
+        """Crea un nuevo usuario en Firestore."""
+        if not db: return None, "Error: La base de datos no está disponible."
+        if not name.strip(): return None, "El nombre no puede estar vacío."
+        
+        try:
+            # Generamos un ID de usuario único y legible.
+            user_id = f"{name.lower().replace(' ', '_')}_{int(time.time())}"
+            new_user = User(user_id=user_id, name=name)
+            
+            await UserManager.save_user(new_user)
+            msg = f"¡Bienvenido, {name}! Tu perfil ha sido creado. Guarda bien tu ID de Usuario: **{user_id}**"
+            logging.info(f"Nuevo usuario creado: {name} ({user_id})")
+            return new_user, msg
+        except Exception as e:
+            logging.error(f"Error al crear usuario en Firestore: {e}")
+            return None, f"Error inesperado al crear el perfil: {e}"
+
     @staticmethod
-    def get_environmental_context(): return random.choice(["Soleado", "Nublado", "Lluvioso", "Ventoso"])
+    async def save_user(user: User) -> bool:
+        """Guarda el estado completo de un objeto User en Firestore."""
+        if not db: return False
+        try:
+            user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user.user_id)
+            await asyncio.to_thread(user_doc_ref.set, user.to_dict())
+            return True
+        except Exception as e:
+            logging.error(f"Error al guardar usuario {user.user_id} en Firestore: {e}")
+            return False
+
+# ==============================================================================
+# MÓDULO 5: MOTOR DE PERSONA Y LÓGICA DE IA
+# ==============================================================================
+# Este es el cerebro de MateAI. Aquí se toma el perfil del usuario,
+# el contexto actual y el mensaje para generar una respuesta coherente,
+# empática y personalizada.
+# ==============================================================================
+
+class PersonaEngine:
+    """Orquesta la lógica de IA para generar respuestas y gestionar la interacción."""
+    
+    def __init__(self, user: User):
+        self.user = user
+
+    async def analyze_sentiment(self, text: str) -> Dict[str, float]:
+        """Analiza el sentimiento del texto del usuario."""
+        if not sentiment_analyzer:
+            # Fallback si el modelo no cargó.
+            return {"label": "NEU", "score": 1.0}
+        
+        try:
+            # Ejecutamos el análisis en un hilo separado para no bloquear la app.
+            analysis = await asyncio.to_thread(sentiment_analyzer.predict, text)
+            return {"label": analysis.output, "score": analysis.probas[analysis.output]}
+        except Exception as e:
+            logging.error(f"Error en análisis de sentimiento: {e}")
+            return {"label": "NEU", "score": 1.0}
+
+    def _get_greeting(self) -> str:
+        """Genera un saludo personalizado basado en la hora y el perfil."""
+        hour = datetime.now().hour
+        if 5 <= hour < 12: time_greeting = "Buen día"
+        elif 12 <= hour < 19: time_greeting = "Buenas tardes"
+        else: time_greeting = "Buenas noches"
 
-class NudgeGenerator:
-    def __init__(self, user_manager, context_engine):
-        self.user_manager = user_manager
-        self.context_engine = context_engine
-    async def get_daily_oracle_revelation(self, user_id): return "El Oráculo te sonríe hoy."
-    async def get_mateai_challenge(self, user_id): return "Tu desafío: hacé una pausa de 5 minutos."
-    async def generate_nudge(self, user_id, location, activity, sentiment): return f"Susurro para {user_id} en {location} mientras está {activity} y se siente {sentiment}.", 1, "Insignia", "Próxima", []
+        # Personalización del saludo
+        if self.user.psych_profile['extraversion'] > 0.5:
+            return f"¡{time_greeting}, {self.user.name}! ¡Qué bueno verte! ¿En qué andamos hoy?"
+        elif self.user.psych_profile['neuroticism'] > 0.4:
+            return f"{time_greeting}, {self.user.name}. Espero que estés teniendo un día tranquilo. ¿Cómo te sentís?"
+        else:
+            return f"{time_greeting}, {self.user.name}. Un gusto conectar de nuevo."
+
+    async def generate_proactive_checkin(self) -> Optional[str]:
+        """Genera un mensaje proactivo si ha pasado suficiente tiempo."""
+        now = datetime.now()
+        if self.user.last_proactive_checkin:
+            if now - self.user.last_proactive_checkin < timedelta(hours=Config.PROACTIVE_CHECKIN_HOURS):
+                return None # Aún no es tiempo.
+
+        # Lógica de check-in
+        self.user.last_proactive_checkin = now
+        await UserManager.save_user(self.user)
+        
+        # Ejemplo de check-in personalizado
+        if self.user.psych_profile['conscientiousness'] > 0.5 and self.user.goals:
+            pending_goals = [g['name'] for g in self.user.goals if not g.get('completed')]
+            if pending_goals:
+                return f"¡Hola {self.user.name}! Solo pasaba a saludar y recordarte que tenés metas increíbles como '{pending_goals[0]}' en marcha. ¡Cualquier pasito cuenta!"
+        
+        return self._get_greeting() + " Solo pasaba a ver cómo estabas."
+        
+    async def generate_response(self, message: str) -> str:
+        """El método principal que genera la respuesta de MateAI a un mensaje."""
+        # 1. Analizar el sentimiento del mensaje del usuario
+        sentiment = await self.analyze_sentiment(message)
+        
+        # 2. Registrar el mensaje en la memoria del usuario
+        self.user.add_memory(content=message, memory_type="chat", sentiment=sentiment)
+
+        # 3. Lógica de respuesta basada en triggers y perfil
+        # TODO: Implementar un sistema de comandos más robusto (ej. /metas, /perfil)
+        
+        # 3.1 Manejo de respuestas empáticas a sentimientos fuertes
+        if sentiment['label'] == 'NEG' and sentiment['score'] > 0.7:
+             return f"Noto que lo que decís tiene una carga fuerte, {self.user.name}. Si querés hablar de ello, acá estoy para escucharte sin juzgar."
+
+        # 3.2 Lógica de preguntas para construir el perfil (si aún es genérico)
+        # Esta es la parte de "tricky psychological questions"
+        if abs(sum(self.user.psych_profile.values())) < 0.1: # Perfil casi virgen
+            return await self._ask_profiling_question()
+            
+        # 3.3 Respuesta por defecto (placeholder para lógica más compleja)
+        # Aquí se integraría con un LLM si lo tuviéramos.
+        # Por ahora, una respuesta reflexiva basada en el perfil.
+        
+        response = self._craft_default_response(sentiment)
+        
+        # 4. Guardar el estado actualizado del usuario
+        await UserManager.save_user(self.user)
+        
+        return response
+
+    def _craft_default_response(self, sentiment: Dict[str, float]) -> str:
+        """Crea una respuesta genérica pero personalizada."""
+        responses = [
+            f"Interesante lo que mencionás, {self.user.name}. Me hace pensar en...",
+            f"Entiendo tu punto, {self.user.name}. ¿Cómo se conecta eso con tus metas actuales?",
+            f"Gracias por compartir eso. Cada charla nos ayuda a entendernos mejor.",
+        ]
+        
+        if self.user.psych_profile['openness'] > 0.5:
+            responses.append(f"Eso abre una puerta a una idea nueva. ¿Qué pasaría si lo miramos desde otro ángulo?")
+        if sentiment['label'] == 'POS':
+            responses.append(f"¡Me encanta esa energía, {self.user.name}! Es genial verte así.")
+            
+        return random.choice(responses)
 
+    async def _ask_profiling_question(self) -> str:
+        """Selecciona y hace una pregunta sutil para definir el perfil psicológico."""
+        # Ejemplo de pregunta para medir "Apertura a la experiencia" vs "Consciencia"
+        question = (
+            f"Una pregunta curiosa, {self.user.name}: si tuvieras una tarde libre inesperada, "
+            "¿qué te tienta más? \n"
+            "A) Improvisar y ver a dónde te lleva el día, quizás descubrir un café nuevo o un parque. \n"
+            "B) Aprovechar para organizar esa pila de libros, planificar la semana o adelantar una tarea pendiente."
+        )
+        self.user.short_term_context['last_question'] = "openness_vs_conscientiousness"
+        await UserManager.save_user(self.user)
+        return question
 
-# --- MÓDULO 8: LA NUEVA INTERFAZ GRÁFICA (REDISENIO TOTAL) ---
+    def process_profiling_answer(self, answer: str):
+        """Procesa la respuesta a una pregunta de perfilado y actualiza el psych_profile."""
+        question_type = self.user.short_term_context.get('last_question')
+        if not question_type: return
+
+        answer_lower = answer.lower()
+        if question_type == "openness_vs_conscientiousness":
+            if 'a' in answer_lower or 'improvisar' in answer_lower:
+                self.user.psych_profile['openness'] += 0.3
+                self.user.psych_profile['conscientiousness'] -= 0.1
+            elif 'b' in answer_lower or 'organizar' in answer_lower:
+                self.user.psych_profile['conscientiousness'] += 0.3
+                self.user.psych_profile['openness'] -= 0.1
+        
+        # Limpiamos el contexto para no procesar de nuevo.
+        del self.user.short_term_context['last_question']
+        
+        # Añadimos puntos por la introspección
+        self.user.connection_points += Config.POINTS_PER_INSIGHT
+        logging.info(f"Perfil de {self.user.name} actualizado. Puntos: {self.user.connection_points}")
 
-# --- Funciones de Lógica de la Interfaz (REFORZADAS) ---
-async def login_or_create_user(action, username, userid, prefs_tipo):
-    user, msg = (None, "")
-    if action == "login":
-        if not userid:
+
+# ==============================================================================
+# MÓDULO 6: LÓGICA Y ESTRUCTURA DE LA INTERFAZ DE USUARIO (GRADIO)
+# ==============================================================================
+# Aquí se conectan todos los módulos anteriores con la interfaz gráfica.
+# Las funciones aquí son "controladores" que reciben eventos de la UI
+# y orquestan las acciones de los motores de backend.
+# ==============================================================================
+
+# --- Funciones de Lógica de la Interfaz ---
+
+async def handle_login_or_creation(action: str, name: str, user_id: str) -> tuple:
+    """Controlador para los botones de login y creación."""
+    if action == "create":
+        if not name:
+            gr.Warning("Para crear un perfil, necesito que me digas tu nombre.")
+            return None, gr.update(), gr.update(visible=True), gr.update(visible=False)
+        user, msg = await UserManager.create_user(name)
+    elif action == "login":
+        if not user_id:
             gr.Warning("¡Che, poné tu ID para cargar el perfil!")
-            return None, gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
-        user, msg = await UserManager.login_user(userid)
-    else: # action == "create"
-        if not username:
-            gr.Warning("¡Capo, necesitás un nombre para crear un perfil!")
-            return None, gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
-        user, msg = await UserManager.create_user(username, {"tipo_susurro": prefs_tipo})
+            return None, gr.update(), gr.update(visible=True), gr.update(visible=False)
+        user = await UserManager.get_user(user_id)
+        msg = f"¡Hola de nuevo, {user.name}! Perfil cargado." if user else "ID de usuario no encontrado. Verificá que esté bien escrito."
+    else:
+        return None, "Acción desconocida.", gr.update(visible=True), gr.update(visible=False)
 
     if user:
         gr.Success(msg)
-        welcome_msg = f"¡Hola de nuevo, {user.name}! Eco-Puntos: {user.eco_points}"
-        task_list, task_dropdown = await get_task_updates(user)
-        # SOLUCIÓN: Usar .get() para máxima seguridad, aunque ya no debería ser necesario.
-        return (user, welcome_msg, gr.update(interactive=True), 
-                gr.update(value=user.preferences.get("tipo_susurro", "ambos")), 
-                gr.update(value=user.preferences.get("modo_che_tranqui", False)), 
-                gr.update(value=user.preferences.get("voice_uri", "default")), 
-                task_list, task_dropdown)
+        # Al loguearse, ocultamos el panel de login y mostramos el de chat.
+        initial_greeting = PersonaEngine(user)._get_greeting()
+        chat_history = [{"role": "assistant", "content": initial_greeting}]
+        return user, chat_history, gr.update(visible=False), gr.update(visible=True)
     else:
-        gr.Warning(msg)
-        return None, "Iniciá sesión o creá un perfil para empezar.", gr.update(interactive=False), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
+        gr.Error(msg)
+        return None, gr.update(), gr.update(visible=True), gr.update(visible=False)
 
-async def update_preferences(user, tipo, tranqui, voice):
-    if not user:
-        gr.Warning("Primero tenés que iniciar sesión.")
-        return user, gr.update()
-    user.preferences["tipo_susurro"] = tipo
-    user.preferences["modo_che_tranqui"] = tranqui
-    user.preferences["voice_uri"] = voice
-    await UserManager.update_user_data(user)
-    gr.Success("¡Preferencias actualizadas, master!")
-    return user, f"¡Hola de nuevo, {user.name}! Eco-Puntos: {user.eco_points}"
-    
-async def get_task_updates(user):
-    if not user or not user.tasks:
-        return "No tenés tareas pendientes.", gr.Dropdown(choices=[], value=None, label="Seleccioná una tarea para completar")
-    task_list_str = "\n".join([f"• {t['task']}" for t in user.tasks])
-    task_choices = [t['task'] for t in user.tasks]
-    return task_list_str, gr.Dropdown(choices=task_choices, value=None, label="Seleccioná una tarea para completar")
-
-async def add_task(user, task_name):
-    if not user: return user, gr.Warning("Iniciá sesión para agregar tareas."), gr.update(), gr.update()
-    if not task_name: return user, gr.Info("¿Qué tarea querés agregar?"), gr.update(), gr.update()
-    user.tasks.append({"task": task_name, "added_at": datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')})
-    await UserManager.update_user_data(user)
-    task_list, task_dropdown = await get_task_updates(user)
-    return user, gr.Success(f"Tarea '{task_name}' agregada."), task_list, task_dropdown
-
-async def complete_task(user, task_to_complete):
-    if not user: return user, gr.Warning("Iniciá sesión para completar tareas."), gr.update(), gr.update()
-    if not task_to_complete: return user, gr.Info("Seleccioná una tarea de la lista."), gr.update(), gr.update()
-    user.tasks = [t for t in user.tasks if t['task'] != task_to_complete]
-    await UserManager.update_user_data(user)
-    task_list, task_dropdown = await get_task_updates(user)
-    return user, gr.Success(f"¡Bien ahí! Tarea '{task_to_complete}' completada."), task_list, task_dropdown
-
-async def get_oracle(user):
-    if not user: return gr.Warning("Iniciá sesión para consultar al Oráculo."), ""
-    revelation = await NudgeGenerator(UserManager, ContextEngine).get_daily_oracle_revelation(user.user_id)
-    return revelation, revelation
-
-async def get_challenge(user):
-    if not user: return gr.Warning("Iniciá sesión para recibir un desafío."), ""
-    challenge = await NudgeGenerator(UserManager, ContextEngine).get_mateai_challenge(user.user_id)
-    return challenge, challenge
-
-async def process_chat(user, message, chat_history, conv_context):
-    if not user:
-        gr.Warning("¡Che, para arrancar, cargá tu perfil en la pestaña 'Perfil y Configuración'!")
-        return user, chat_history, conv_context, "", gr.update(), gr.update(), gr.update()
-    
-    # SOLUCIÓN: Usar el formato de `messages` para el historial de chat
+async def handle_chat_message(user_state: User, message: str, chat_history: List[Dict]) -> tuple:
+    """Controlador principal para cada mensaje enviado por el usuario."""
+    if not user_state:
+        gr.Warning("¡Para empezar, creá un perfil o iniciá sesión!")
+        return user_state, chat_history, ""
+
+    # Agregamos el mensaje del usuario a la UI inmediatamente para dar feedback visual.
     chat_history.append({"role": "user", "content": message})
-    msg_lower = message.lower()
-    response, task_list, task_dropdown, notif = "", gr.update(), gr.update(), gr.update()
-
-    if "agregar tarea" in msg_lower or "anotá esto" in msg_lower:
-        task_name = message.replace("agregar tarea", "", 1).replace("anotá esto", "", 1).strip()
-        user, notif, task_list, task_dropdown = await add_task(user, task_name)
-        response = f"¡Listo! Tarea '{task_name}' agregada."
-    elif "oráculo" in msg_lower or "revelación" in msg_lower:
-        response, _ = await get_oracle(user)
-    elif "desafío" in msg_lower or "reto" in msg_lower:
-        response, _ = await get_challenge(user)
-    else:
-        location = random.choice(["Casa", "Oficina/Estudio", "Aire Libre/Calle"])
-        activity = random.choice(["Trabajando", "Relajado", "Ejercicio"])
-        response, _, _, _, _ = await NudgeGenerator(UserManager, ContextEngine).generate_nudge(user.user_id, location, activity, "Bien")
     
-    chat_history.append({"role": "assistant", "content": response})
-    voice_uri = user.preferences.get("voice_uri", "default")
-    return user, chat_history, conv_context, (response, voice_uri), task_list, task_dropdown, notif
+    # Creamos una instancia del motor de persona con el estado actual del usuario.
+    engine = PersonaEngine(user_state)
 
-# --- ESTRUCTURA DE LA INTERFAZ (LA CASA NUEVA) ---
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald", secondary_hue="orange"), css="#voice_btn { max-width: 250px; margin: 10px auto; }") as demo:
-    current_user = gr.State(None)
-    conversation_context = gr.State({})
-    voice_output = gr.State()
-    notification_output = gr.Textbox(visible=False) # Para mostrar notificaciones
-    
-    gr.HTML("""...""") # El JS para la voz no cambia
-    
-    with gr.Row():
-        welcome_message = gr.Markdown("### 🧉 ¡Bienvenido a MateAI! Iniciá sesión o creá un perfil para empezar.")
-    
-    with gr.Tabs() as tabs:
-        with gr.TabItem("💬 Conversar con MateAI", id=0):
-            # SOLUCIÓN: Corregir advertencias de Gradio
-            chatbot = gr.Chatbot(label="Conversación", height=450, type="messages")
-            with gr.Row():
-                chat_input = gr.Textbox(show_label=False, placeholder="Escribí acá o usá el micrófono...", scale=4)
-                send_button = gr.Button("Enviar", variant="primary", scale=1)
-            gr.Button("🎙️ Hablar con MateAI", elem_id="voice_btn") 
-
-        with gr.TabItem("👤 Perfil y Configuración", id=1):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("#### 🧉 Usuario Nuevo")
-                    username_input = gr.Textbox(label="Tu Nombre o Apodo")
-                    prefs_tipo_inicial = gr.Dropdown(["ambos", "eco", "bienestar"], label="Preferencia de Susurros", value="ambos")
-                    create_button = gr.Button("¡Crear Perfil!", variant="primary")
-                with gr.Column(scale=1):
-                    gr.Markdown("#### 🧉 Cargar Perfil")
-                    userid_input = gr.Textbox(label="Tu ID de Usuario")
-                    login_button = gr.Button("Cargar Perfil")
-            
-            with gr.Group(interactive=False) as prefs_group:
-                 gr.Markdown("--- \n ### ⚙️ Tus Preferencias")
-                 prefs_tipo_update = gr.Dropdown(["ambos", "eco", "bienestar"], label="Tipo de susurro preferido")
-                 prefs_tranqui_update = gr.Checkbox(label="Activar 'Modo Che, Tranqui'")
-                 # SOLUCIÓN: Permitir valor custom para evitar warning al inicio
-                 voice_selector = gr.Dropdown(label="Selector de Voz (si la automática no te gusta)", choices=[], value="default", allow_custom_value=True)
-                 update_prefs_button = gr.Button("Guardar Preferencias", variant="primary")
-
-        with gr.TabItem("📝 Gestor de Tareas", id=2):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("#### ➕ **Agregar Tarea**")
-                    new_task_input = gr.Textbox(label="Nombre de la nueva tarea")
-                    add_task_button = gr.Button("Agregar", variant="primary")
-                with gr.Column():
-                    gr.Markdown("#### ✔️ **Completar Tarea**")
-                    task_to_complete_dd = gr.Dropdown(label="Seleccioná una tarea para completar", choices=[])
-                    complete_task_button = gr.Button("¡Tarea Lista!")
-            gr.Markdown("--- \n ### 📋 Tus Tareas Pendientes")
-            task_list_output = gr.Markdown("No tenés tareas pendientes.")
-
-        with gr.TabItem("✨ Oráculo & Desafíos", id=3):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### ✨ La Revelación Diaria")
-                    oracle_button = gr.Button("Consultar al Oráculo")
-                    oracle_output = gr.Textbox(label="El Oráculo dice...", lines=5, interactive=False)
-                with gr.Column():
-                    gr.Markdown("### 🎯 Desafío MateAI")
-                    challenge_button = gr.Button("¡Dame un Desafío!")
-                    challenge_output = gr.Textbox(label="Tu misión es...", lines=5, interactive=False)
-
-    # --- LÓGICA DE EVENTOS DE LA INTERFAZ ---
-    demo.load(fn=None, inputs=None, outputs=[voice_selector], js="async () => { return window.getVoices() }")
+    # Verificamos si la respuesta es a una pregunta de perfilado.
+    if user_state.short_term_context.get('last_question'):
+        engine.process_profiling_answer(message)
+        response = "¡Bárbaro! Gracias por compartirlo. Lo tengo en cuenta para que nos entendamos mejor."
+    else:
+        # Si no, generamos una respuesta normal.
+        response = await engine.generate_response(message)
     
-    login_outputs = [current_user, welcome_message, prefs_group, prefs_tipo_update, prefs_tranqui_update, voice_selector, task_list_output, task_to_complete_dd]
-    login_button.click(fn=login_or_create_user, inputs=[gr.State("login"), username_input, userid_input, prefs_tipo_inicial], outputs=login_outputs)
-    create_button.click(fn=login_or_create_user, inputs=[gr.State("create"), username_input, userid_input, prefs_tipo_inicial], outputs=login_outputs)
+    # Agregamos la respuesta de MateAI al historial.
+    chat_history.append({"role": "assistant", "content": response})
     
-    update_prefs_button.click(fn=update_preferences, inputs=[current_user, prefs_tipo_update, prefs_tranqui_update, voice_selector], outputs=[current_user, welcome_message])
+    # El estado del usuario (user_state) ha sido modificado por el engine,
+    # así que lo devolvemos para actualizar el gr.State
+    return user_state, chat_history, "" # Limpiamos el textbox de input
+
+def render_profile_info(user: Optional[User]) -> str:
+    """Genera un texto Markdown con la información del perfil del usuario."""
+    if not user:
+        return "Cargá un perfil para ver tu información."
+        
+    profile_md = f"### Perfil de {user.name}\n"
+    profile_md += f"**ID de Usuario:** `{user.user_id}`\n"
+    profile_md += f"**Puntos de Conexión:** {user.connection_points} 💠\n\n"
+    profile_md += "#### Modelo de Personalidad (inferido):\n"
+    for trait, value in user.psych_profile.items():
+        # Visualización simple del rasgo
+        bar = "■" * int((value + 1) * 5)  # Escala de 0 a 10
+        profile_md += f"- **{trait.capitalize()}:** `{f'{value:.2f}'}` {bar}\n"
     
-    add_task_button.click(fn=add_task, inputs=[current_user, new_task_input], outputs=[current_user, notification_output, task_list_output, task_to_complete_dd]).then(lambda: "", outputs=[new_task_input])
-    complete_task_button.click(fn=complete_task, inputs=[current_user, task_to_complete_dd], outputs=[current_user, notification_output, task_list_output, task_to_complete_dd])
+    return profile_md
+
+# --- Construcción de la Interfaz con Gradio Blocks ---
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"), css="footer {display: none !important}") as demo:
     
-    oracle_button.click(fn=get_oracle, inputs=[current_user], outputs=[oracle_output, voice_output])
-    challenge_button.click(fn=get_challenge, inputs=[current_user], outputs=[challenge_output, voice_output])
+    # Estado de la aplicación: el objeto User se mantiene aquí durante toda la sesión.
+    current_user = gr.State(None)
     
-    chat_outputs = [current_user, chatbot, conversation_context, voice_output, task_list_output, task_to_complete_dd, notification_output]
-    send_button.click(fn=process_chat, inputs=[current_user, chat_input, chatbot, conversation_context], outputs=chat_outputs).then(lambda: "", outputs=[chat_input])
-    chat_input.submit(fn=process_chat, inputs=[current_user, chat_input, chatbot, conversation_context], outputs=chat_outputs).then(lambda: "", outputs=[chat_input])
+    gr.Markdown(f"# 🧉 {Config.APP_NAME}")
+    gr.Markdown(f"*{Config.APP_VERSION}* - Tu compañero de IA para la introspección y el crecimiento.")
+
+    with gr.Row():
+        # Columna de la izquierda: Chat y Perfil
+        with gr.Column(scale=2):
+            # Panel de Chat (inicialmente oculto)
+            with gr.Box(visible=False) as chat_panel:
+                chatbot = gr.Chatbot(label="Conversación con MateAI", height=600, type="messages")
+                with gr.Row():
+                    chat_input = gr.Textbox(show_label=False, placeholder="Escribí acá con confianza...", scale=4)
+                    send_button = gr.Button("Enviar", variant="primary", scale=1)
+
+            # Panel de Login (inicialmente visible)
+            with gr.Box(visible=True) as login_panel:
+                gr.Markdown("### 🌟 Para empezar...")
+                with gr.Tabs():
+                    with gr.TabItem("Crear Perfil Nuevo"):
+                        username_input = gr.Textbox(label="Tu Nombre o Apodo")
+                        create_button = gr.Button("¡Crear mi MateAI!", variant="primary")
+                    with gr.TabItem("Cargar Perfil Existente"):
+                        userid_input = gr.Textbox(label="Tu ID de Usuario")
+                        login_button = gr.Button("Cargar Perfil")
+        
+        # Columna de la derecha: Información de contexto
+        with gr.Column(scale=1):
+            with gr.Box():
+                gr.Markdown("### 🧠 Tu Perfil")
+                profile_display = gr.Markdown("Cargá un perfil para ver tu información.")
+
+    # --- Lógica de Eventos de la Interfaz ---
+
+    # Acciones de Login y Creación
+    login_button.click(
+        fn=handle_login_or_creation, 
+        inputs=[gr.State("login"), username_input, userid_input], 
+        outputs=[current_user, chatbot, login_panel, chat_panel]
+    )
+    create_button.click(
+        fn=handle_login_or_creation, 
+        inputs=[gr.State("create"), username_input, userid_input], 
+        outputs=[current_user, chatbot, login_panel, chat_panel]
+    )
     
-    voice_output.change(fn=None, inputs=[voice_output], js="(text_and_voice) => { if (text_and_voice) { window.speakText(text_and_voice[0], text_and_voice[1]) } }")
-    # Manejar las notificaciones de éxito o error
-    notification_output.change(fn=lambda x: x, inputs=[notification_output], outputs=[gr.Info(visible=True)])
+    # Acción de enviar mensaje en el chat
+    chat_submit_action = send_button.click if send_button else chat_input.submit
+    chat_submit_action(
+        fn=handle_chat_message,
+        inputs=[current_user, chat_input, chatbot],
+        outputs=[current_user, chatbot, chat_input]
+    )
+    chat_input.submit(
+        fn=handle_chat_message,
+        inputs=[current_user, chat_input, chatbot],
+        outputs=[current_user, chatbot, chat_input]
+    )
+
+    # Actualización dinámica del panel de perfil cuando cambia el estado del usuario
+    current_user.change(
+        fn=render_profile_info,
+        inputs=[current_user],
+        outputs=[profile_display]
+    )
 
 if __name__ == "__main__":
+    # Para lanzar la aplicación
+    # En un entorno de producción como Hugging Face Spaces, no es necesario debug=True
     demo.launch(debug=True)