Update modules/database.py

modules/database.py

@@ -1,481 +1,474 @@
-import sqlite3
-import json
-import time
-from typing import Optional, List, Dict, Any
-
-class Database:
-    def __init__(self, db_path):
-        self.db_path = db_path
-        self.max_retries = 5
-        self.retry_delay = 0.1
-        self._init_db()
-
-    def _get_connection(self) -> sqlite3.Connection:
-        """Get database connection with retry logic"""
-        for attempt in range(self.max_retries):
-            try:
-                conn = sqlite3.connect(self.db_path, timeout=30.0)
-                # Enable WAL mode for better concurrency
-                conn.execute('PRAGMA journal_mode=WAL')
-                conn.execute('PRAGMA synchronous=NORMAL')
-                conn.execute('PRAGMA cache_size=1000')
-                conn.execute('PRAGMA temp_store=MEMORY')
-                conn.execute('PRAGMA busy_timeout=30000')  # 30 seconds
-                return conn
-            except sqlite3.OperationalError as e:
-                if "database is locked" in str(e) and attempt < self.max_retries - 1:
-                    time.sleep(self.retry_delay * (2 ** attempt))  # Exponential backoff
-                    continue
-                raise e
-        raise sqlite3.OperationalError("Failed to acquire database connection after retries")
-
-    def _execute_with_retry(self, query: str, params: Optional[tuple] = None, commit: bool = False) -> Optional[List[tuple]]:
-        """Execute query with retry logic"""
-        for attempt in range(self.max_retries):
-            try:
-                with self._get_connection() as conn:
-                    c = conn.cursor()
-                    if params:
-                        c.execute(query, params)
-                    else:
-                        c.execute(query)
-
-                    result = c.fetchall() if query.strip().upper().startswith('SELECT') else None
-
-                    if commit:
-                        conn.commit()
-
-                    return result
-            except sqlite3.OperationalError as e:
-                if "database is locked" in str(e) and attempt < self.max_retries - 1:
-                    time.sleep(self.retry_delay * (2 ** attempt))
-                    continue
-                raise e
-        raise sqlite3.OperationalError("Failed to execute query after retries")
-
-    def _init_db(self):
-        with self._get_connection() as conn:
-            c = conn.cursor()
-
-            # Tabela de aprendizado
-            c.execute('''CREATE TABLE IF NOT EXISTS aprendizado (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                usuario TEXT,
-                dado TEXT,
-                valor TEXT
-            )''')
-            # Tabela de exemplos
-            c.execute('''CREATE TABLE IF NOT EXISTS exemplos (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                tipo TEXT NOT NULL,
-                entrada TEXT NOT NULL,
-                resposta TEXT NOT NULL
-            )''')
-            # Tabela info_geral
-            c.execute('''CREATE TABLE IF NOT EXISTS info_geral (
-                chave TEXT PRIMARY KEY,
-                valor TEXT NOT NULL
-            )''')
-            # Tabela estilos
-            c.execute('''CREATE TABLE IF NOT EXISTS estilos (
-                numero_usuario TEXT PRIMARY KEY,
-                estilo TEXT NOT NULL
-            )''')
-            # Tabela preferencias_tom
-            c.execute('''CREATE TABLE IF NOT EXISTS preferencias_tom (
-                numero_usuario TEXT PRIMARY KEY,
-                tom TEXT NOT NULL
-            )''')
-            # Tabela afinidades
-            c.execute('''CREATE TABLE IF NOT EXISTS afinidades (
-                numero_usuario TEXT PRIMARY KEY,
-                afinidade REAL NOT NULL
-            )''')
-            # Tabela termos
-            c.execute('''CREATE TABLE IF NOT EXISTS termos (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                numero_usuario TEXT NOT NULL,
-                termo TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-            # Tabela aprendizados (versão detalhada)
-            c.execute('''CREATE TABLE IF NOT EXISTS aprendizados (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                numero_usuario TEXT NOT NULL,
-                chave TEXT NOT NULL,
-                valor TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-            # Tabela vocabulário_patenteado
-            c.execute('''CREATE TABLE IF NOT EXISTS vocabulario_patenteado (
-                termo TEXT PRIMARY KEY,
-                definicao TEXT NOT NULL,
-                uso TEXT NOT NULL,
-                exemplo TEXT NOT NULL
-            )''')
-            # Tabela usuarios_privilegiados
-            c.execute('''CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
-                numero_usuario TEXT PRIMARY KEY,
-                nome TEXT NOT NULL
-            )''')
-            # Tabela whatsapp_ids
-            c.execute('''CREATE TABLE IF NOT EXISTS whatsapp_ids (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                whatsapp_id TEXT NOT NULL,
-                sender_number TEXT NOT NULL,
-                UNIQUE (whatsapp_id, sender_number)
-            )''')
-            # Tabela embeddings
-            c.execute('''CREATE TABLE IF NOT EXISTS embeddings (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                texto TEXT NOT NULL,
-                embedding BLOB NOT NULL
-            )''')
-
-            # Tabela mensagens (definição completa e única)
-            c.execute('''CREATE TABLE IF NOT EXISTS mensagens (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                usuario TEXT NOT NULL,
-                mensagem TEXT NOT NULL,
-                resposta TEXT NOT NULL,
-                numero TEXT,
-                is_reply BOOLEAN DEFAULT 0,
-                mensagem_original TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                data TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            # Nova tabela: emocao_exemplos - para armazenar exemplos de emoções
-            c.execute('''CREATE TABLE IF NOT EXISTS emocao_exemplos (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                emocao TEXT NOT NULL,
-                entrada TEXT NOT NULL,
-                resposta TEXT NOT NULL,
-                tom TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            # Nova tabela: girias_aprendidas - para armazenar gírias aprendidas
-            c.execute('''CREATE TABLE IF NOT EXISTS girias_aprendidas (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                numero_usuario TEXT NOT NULL,
-                giria TEXT NOT NULL,
-                significado TEXT NOT NULL,
-                contexto TEXT,
-                frequencia INTEGER DEFAULT 1,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            # Nova tabela: tom_usuario - para rastrear tom do usuário
-            c.execute('''CREATE TABLE IF NOT EXISTS tom_usuario (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                numero_usuario TEXT NOT NULL,
-                tom_detectado TEXT NOT NULL,
-                intensidade REAL DEFAULT 0.5,
-                contexto TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            # Nova tabela: adaptacao_dinamica - para armazenar adaptações dinâmicas
-            c.execute('''CREATE TABLE IF NOT EXISTS adaptacao_dinamica (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                numero_usuario TEXT NOT NULL,
-                tipo_adaptacao TEXT NOT NULL,
-                valor_anterior TEXT,
-                valor_novo TEXT,
-                razao TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            )''')
-
-            conn.commit()
-
-            # Migration melhorada: verificar e adicionar colunas necessárias
-            self._migrate_mensagens_table(c, conn)
-
-    def _migrate_mensagens_table(self, cursor, conn):
-        """Migração específica para garantir que a tabela mensagens tenha todas as colunas necessárias"""
-        try:
-            cursor.execute("PRAGMA table_info('mensagens')")
-            existing_cols = {row[1] for row in cursor.fetchall()}
-
-            # Colunas que devem existir
-            required_cols = {
-                'numero': "ALTER TABLE mensagens ADD COLUMN numero TEXT",
-                'is_reply': "ALTER TABLE mensagens ADD COLUMN is_reply BOOLEAN DEFAULT 0",
-                'mensagem_original': "ALTER TABLE mensagens ADD COLUMN mensagem_original TEXT",
-                'created_at': "ALTER TABLE mensagens ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP",
-                'data': "ALTER TABLE mensagens ADD COLUMN data TIMESTAMP DEFAULT CURRENT_TIMESTAMP"
-            }
-
-            # Adicionar colunas que não existem
-            for col_name, alter_stmt in required_cols.items():
-                if col_name not in existing_cols:
-                    try:
-                        cursor.execute(alter_stmt)
-                        conn.commit()
-                        print(f"Coluna '{col_name}' adicionada à tabela mensagens")
-                    except sqlite3.Error as e:
-                        print(f"Erro ao adicionar coluna '{col_name}': {e}")
-
-        except sqlite3.Error as e:
-            print(f"Erro durante migração da tabela mensagens: {e}")
-
-    # Métodos para EXEMPLOS
-    def inserir_exemplo(self, tipo, entrada, resposta):
-        self._execute_with_retry("INSERT INTO exemplos (tipo, entrada, resposta) VALUES (?, ?, ?)", (tipo, entrada, resposta), commit=True)
-
-    def recuperar_exemplos(self, tipo=None):
-        if tipo:
-            return self._execute_with_retry("SELECT entrada, resposta FROM exemplos WHERE tipo=? ORDER BY id DESC", (tipo,))
-        else:
-            return self._execute_with_retry("SELECT entrada, resposta FROM exemplos ORDER BY id DESC")
-
-    # Métodos para INFO_GERAL
-    def salvar_info_geral(self, chave, valor):
-        self._execute_with_retry("INSERT OR REPLACE INTO info_geral (chave, valor) VALUES (?, ?)", (chave, valor), commit=True)
-
-    def recuperar_info_geral(self, chave):
-        result = self._execute_with_retry("SELECT valor FROM info_geral WHERE chave=?", (chave,))
-        return result[0][0] if result else None
-
-    # Métodos para ESTILOS
-    def salvar_estilo(self, numero_usuario, estilo):
-        self._execute_with_retry("INSERT OR REPLACE INTO estilos (numero_usuario, estilo) VALUES (?, ?)", (numero_usuario, estilo), commit=True)
-
-    def recuperar_estilo(self, numero_usuario):
-        result = self._execute_with_retry("SELECT estilo FROM estilos WHERE numero_usuario=?", (numero_usuario,))
-        return result[0][0] if result else None
-
-    # Métodos para PREFERENCIAS_TOM
-    def salvar_preferencia_tom(self, numero_usuario, tom):
-        self._execute_with_retry("INSERT OR REPLACE INTO preferencias_tom (numero_usuario, tom) VALUES (?, ?)", (numero_usuario, tom), commit=True)
-
-    def recuperar_preferencia_tom(self, numero_usuario):
-        result = self._execute_with_retry("SELECT tom FROM preferencias_tom WHERE numero_usuario=?", (numero_usuario,))
-        return result[0][0] if result else None
-
-    # Métodos para AFINIDADES
-    def salvar_afinidade(self, numero_usuario, afinidade):
-        self._execute_with_retry("INSERT OR REPLACE INTO afinidades (numero_usuario, afinidade) VALUES (?, ?)", (numero_usuario, afinidade), commit=True)
-
-    def recuperar_afinidade(self, numero_usuario):
-        result = self._execute_with_retry("SELECT afinidade FROM afinidades WHERE numero_usuario=?", (numero_usuario,))
-        return result[0][0] if result else None
-
-    # Métodos para TERMOS
-    def registrar_termo(self, numero_usuario, termo):
-        self._execute_with_retry("INSERT INTO termos (numero_usuario, termo) VALUES (?, ?)", (numero_usuario, termo), commit=True)
-
-    def recuperar_termos(self, numero_usuario):
-        result = self._execute_with_retry("SELECT termo FROM termos WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
-        return [row[0] for row in result] if result else []
-
-    # Métodos para APRENDIZADOS (detalhado)
-    def salvar_aprendizado_detalhado(self, numero_usuario, chave, valor):
-        self._execute_with_retry("INSERT INTO aprendizados (numero_usuario, chave, valor) VALUES (?, ?, ?)", (numero_usuario, chave, valor), commit=True)
-
-    def recuperar_aprendizado_detalhado(self, numero_usuario, chave=None):
-        if chave:
-            result = self._execute_with_retry("SELECT valor FROM aprendizados WHERE numero_usuario=? AND chave=? ORDER BY created_at DESC LIMIT 1", (numero_usuario, chave))
-            return result[0][0] if result else None
-        else:
-            return self._execute_with_retry("SELECT chave, valor FROM aprendizados WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
-
-    # Métodos para VOCABULARIO_PATENTEADO
-    def registrar_vocabulario_patenteado(self, termo, definicao, uso, exemplo):
-        self._execute_with_retry("INSERT OR REPLACE INTO vocabulario_patenteado (termo, definicao, uso, exemplo) VALUES (?, ?, ?, ?)", (termo, definicao, uso, exemplo), commit=True)
-
-    def recuperar_vocabulario_patenteado(self, termo):
-        result = self._execute_with_retry("SELECT definicao, uso, exemplo FROM vocabulario_patenteado WHERE termo=?", (termo,))
-        return result[0] if result else None
-
-    # Métodos para USUARIOS_PRIVILEGIADOS
-    def adicionar_usuario_privilegiado(self, numero_usuario, nome):
-        self._execute_with_retry("INSERT OR REPLACE INTO usuarios_privilegiados (numero_usuario, nome) VALUES (?, ?)", (numero_usuario, nome), commit=True)
-
-    def verificar_usuario_privilegiado(self, numero_usuario):
-        result = self._execute_with_retry("SELECT nome FROM usuarios_privilegiados WHERE numero_usuario=?", (numero_usuario,))
-        return result[0][0] if result else None
-
-    # Métodos para WHATSAPP_IDS
-    def registrar_whatsapp_id(self, whatsapp_id, sender_number):
-        self._execute_with_retry("INSERT OR IGNORE INTO whatsapp_ids (whatsapp_id, sender_number) VALUES (?, ?)", (whatsapp_id, sender_number), commit=True)
-
-    def recuperar_whatsapp_ids(self, sender_number):
-        result = self._execute_with_retry("SELECT whatsapp_id FROM whatsapp_ids WHERE sender_number=?", (sender_number,))
-        return [row[0] for row in result] if result else []
-
-    # Métodos para EMBEDDINGS
-    def salvar_embedding(self, texto, embedding_bytes):
-        self._execute_with_retry("INSERT INTO embeddings (texto, embedding) VALUES (?, ?)", (texto, embedding_bytes), commit=True)
-
-    def recuperar_embedding(self, texto):
-        result = self._execute_with_retry("SELECT embedding FROM embeddings WHERE texto=? ORDER BY id DESC LIMIT 1", (texto,))
-        return result[0][0] if result else None
-
-    # Métodos para MENSAGENS
-    def salvar_mensagem(self, usuario, mensagem, resposta, numero=None, is_reply=False, mensagem_original=None):
-        """Salva mensagem com tratamento de erro robusto"""
-        try:
-            # Verificar se todas as colunas existem antes de inserir
-            existing_cols_result = self._execute_with_retry("PRAGMA table_info('mensagens')")
-            existing_cols = {row[1] for row in existing_cols_result} if existing_cols_result else set()
-
-            # Construir query dinamicamente baseada nas colunas existentes
-            base_cols = ['usuario', 'mensagem', 'resposta']
-            base_values = [usuario, mensagem, resposta]
-
-            optional_cols = {
-                'numero': numero,
-                'is_reply': is_reply,
-                'mensagem_original': mensagem_original
-            }
-
-            # Adicionar colunas opcionais que existem na tabela
-            for col, val in optional_cols.items():
-                if col in existing_cols:
-                    base_cols.append(col)
-                    base_values.append(val)
-
-            # Construir e executar query
-            placeholders = ', '.join(['?' for _ in base_cols])
-            cols_str = ', '.join(base_cols)
-
-            query = f"INSERT INTO mensagens ({cols_str}) VALUES ({placeholders})"
-            self._execute_with_retry(query, tuple(base_values), commit=True)
-
-        except sqlite3.Error as e:
-            print(f"Erro ao salvar mensagem: {e}")
-            # Fallback: tentar salvar apenas com colunas básicas
-            try:
-                self._execute_with_retry("INSERT INTO mensagens (usuario, mensagem, resposta) VALUES (?, ?, ?)", (usuario, mensagem, resposta), commit=True)
-            except sqlite3.Error as fallback_error:
-                print(f"Erro no fallback ao salvar mensagem: {fallback_error}")
-
-    def recuperar_mensagens(self, usuario, limite=5):
-        return self._execute_with_retry("SELECT mensagem, resposta FROM mensagens WHERE usuario=? ORDER BY id DESC LIMIT ?", (usuario, limite))
-
-    # Métodos para APRENDIZADO
-    def salvar_aprendizado(self, usuario, dado, valor):
-        self._execute_with_retry("INSERT INTO aprendizado (usuario, dado, valor) VALUES (?, ?, ?)", (usuario, dado, valor), commit=True)
-
-    def recuperar_aprendizado(self, usuario, dado):
-        result = self._execute_with_retry("SELECT valor FROM aprendizado WHERE usuario=? AND dado=? ORDER BY id DESC LIMIT 1", (usuario, dado))
-        return result[0][0] if result else None
-
-    # NOVOS MÉTODOS PARA APRENDIZADO AVANÇADO
-
-    # Métodos para EMOCAO_EXEMPLOS
-    def salvar_exemplo_emocao(self, emocao: str, entrada: str, resposta: str, tom: str):
-        """Salva exemplo de resposta para uma emoção específica"""
-        self._execute_with_retry("INSERT INTO emocao_exemplos (emocao, entrada, resposta, tom) VALUES (?, ?, ?, ?)", (emocao, entrada, resposta, tom), commit=True)
-
-    def recuperar_exemplos_emocao(self, emocao: str) -> List[Dict[str, Any]]:
-        """Recupera exemplos de resposta para uma emoção"""
-        result = self._execute_with_retry("SELECT entrada, resposta, tom FROM emocao_exemplos WHERE emocao=? ORDER BY created_at DESC", (emocao,))
-        return [{"entrada": row[0], "resposta": row[1], "tom": row[2]} for row in result] if result else []
-
-    # Métodos para GIRIAS_APRENDIDAS
-    def salvar_giria_aprendida(self, numero_usuario: str, giria: str, significado: str, contexto: Optional[str] = None):
-        """Salva ou atualiza uma gíria aprendida"""
-        # Verificar se já existe
-        existing = self._execute_with_retry("SELECT id, frequencia FROM girias_aprendidas WHERE numero_usuario=? AND giria=?", (numero_usuario, giria))
-        if existing:
-            # Atualizar frequência
-            self._execute_with_retry("UPDATE girias_aprendidas SET frequencia=frequencia+1, updated_at=CURRENT_TIMESTAMP WHERE id=?", (existing[0][0],), commit=True)
-        else:
-            # Inserir nova
-            self._execute_with_retry("INSERT INTO girias_aprendidas (numero_usuario, giria, significado, contexto) VALUES (?, ?, ?, ?)", (numero_usuario, giria, significado, contexto), commit=True)
-
-    def recuperar_girias_usuario(self, numero_usuario: str) -> List[Dict[str, Any]]:
-        """Recupera todas as gírias aprendidas de um usuário"""
-        result = self._execute_with_retry("SELECT giria, significado, contexto, frequencia FROM girias_aprendidas WHERE numero_usuario=? ORDER BY frequencia DESC", (numero_usuario,))
-        return [{"giria": row[0], "significado": row[1], "contexto": row[2], "frequencia": row[3]} for row in result] if result else []
-
-    def buscar_significado_giria(self, numero_usuario: str, giria: str) -> Optional[str]:
-        """Busca o significado de uma gíria específica"""
-        result = self._execute_with_retry("SELECT significado FROM girias_aprendidas WHERE numero_usuario=? AND giria=?", (numero_usuario, giria))
-        return result[0][0] if result else None
-
-    # Métodos para TOM_USUARIO
-    def registrar_tom_usuario(self, numero_usuario: str, tom_detectado: str, intensidade: float = 0.5, contexto: Optional[str] = None):
-        """Registra detecção de tom do usuário"""
-        self._execute_with_retry("INSERT INTO tom_usuario (numero_usuario, tom_detectado, intensidade, contexto) VALUES (?, ?, ?, ?)", (numero_usuario, tom_detectado, intensidade, contexto), commit=True)
-
-    def obter_tom_predominante(self, numero_usuario: str, limite: int = 10) -> Optional[str]:
-        """Obtém o tom predominante do usuário baseado no histórico recente"""
-        result = self._execute_with_retry("""
-            SELECT tom_detectado, COUNT(*) as count
-            FROM tom_usuario
-            WHERE numero_usuario=?
-            ORDER BY created_at DESC
-            LIMIT ?
-            GROUP BY tom_detectado
-            ORDER BY count DESC
-            LIMIT 1
-        """, (numero_usuario, limite))
-        return result[0][0] if result else None
-
-    # Métodos para ADAPTACAO_DINAMICA
-    def registrar_adaptacao(self, numero_usuario: str, tipo_adaptacao: str, valor_anterior: str, valor_novo: str, razao: str):
-        """Registra uma adaptação dinâmica feita pela IA"""
-        self._execute_with_retry("INSERT INTO adaptacao_dinamica (numero_usuario, tipo_adaptacao, valor_anterior, valor_novo, razao) VALUES (?, ?, ?, ?, ?)", (numero_usuario, tipo_adaptacao, valor_anterior, valor_novo, razao), commit=True)
-
-    def obter_adaptacoes_usuario(self, numero_usuario: str, tipo_adaptacao: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Obtém histórico de adaptações de um usuário"""
-        if tipo_adaptacao:
-            result = self._execute_with_retry("SELECT tipo_adaptacao, valor_anterior, valor_novo, razao, created_at FROM adaptacao_dinamica WHERE numero_usuario=? AND tipo_adaptacao=? ORDER BY created_at DESC", (numero_usuario, tipo_adaptacao))
-        else:
-            result = self._execute_with_retry("SELECT tipo_adaptacao, valor_anterior, valor_novo, razao, created_at FROM adaptacao_dinamica WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
-        return [{"tipo": row[0], "anterior": row[1], "novo": row[2], "razao": row[3], "data": row[4]} for row in result] if result else []
-
-    # Método auxiliar para análise de emoções em mensagens
-    def analisar_emocoes_mensagem(self, mensagem: str) -> Dict[str, Any]:
-        """Analisa emoções presentes em uma mensagem"""
-        mensagem_lower = mensagem.lower()
-
-        # Palavras-chave por emoção
-        emocao_keywords = {
-            "feliz": ["feliz", "alegre", "contente", "satisfeito", "ótimo", "bom", "maravilhoso", "incrível", "show", "top"],
-            "triste": ["triste", "deprimido", "chateado", "desanimado", "péssimo", "ruim", "horrível"],
-            "raiva": ["raiva", "irritado", "furioso", "puto", "nervoso", "estressado", "odiando"],
-            "medo": ["medo", "assustado", "preocupado", "ansioso", "nervoso", "temendo"],
-            "surpresa": ["surpreso", "uau", "caramba", "incrível", "impressionado", "wow"],
-            "nojo": ["nojo", "repugnante", "horrível", "detesto", "odeio", "repulsivo"],
-            "amor": ["amo", "adoro", "gosto", "apaixonado", "carinhoso", "afetuoso"],
-            "neutro": []  # fallback
-        }
-
-        # Detectar emoções
-        emocao_detectada = "neutro"
-        intensidade_max = 0
-
-        for emocao, keywords in emocao_keywords.items():
-            if emocao == "neutro":
-                continue
-            count = sum(1 for keyword in keywords if keyword in mensagem_lower)
-            if count > intensidade_max:
-                intensidade_max = count
-                emocao_detectada = emocao
-
-        return {
-            "emocao": emocao_detectada,
-            "intensidade": min(intensidade_max / 3.0, 1.0),  # Normalizar para 0-1
-            "palavras_chave_encontradas": intensidade_max
-        }
-
-    # Método para obter contexto completo de aprendizado de usuário
-    def obter_contexto_aprendizado(self, numero_usuario: str) -> Dict[str, Any]:
-        """Obtém contexto completo de aprendizado de um usuário para adaptação dinâmica"""
-        contexto = {
-            "girias": self.recuperar_girias_usuario(numero_usuario),
-            "tom_predominante": self.obter_tom_predominante(numero_usuario),
-            "estilo": self.recuperar_estilo(numero_usuario),
-            "preferencia_tom": self.recuperar_preferencia_tom(numero_usuario),
-            "afinidade": self.recuperar_afinidade(numero_usuario),
-            "adaptacoes_recentes": self.obter_adaptacoes_usuario(numero_usuario)[-5:],  # Últimas 5
-            "aprendizados_detalhados": self.recuperar_aprendizado_detalhado(numero_usuario)
-        }
-
-        return contexto
+import sqlite3
+import json
+import time
+import logging
+from typing import Optional, List, Dict, Any, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self.max_retries = 5
+        self.retry_delay = 0.1
+        self._init_db()
+        self._ensure_all_columns_and_indexes()
+
+    # ================================================================
+    # CONEXÃO COM RETRY + WAL
+    # ================================================================
+
+    def _get_connection(self) -> sqlite3.Connection:
+        for attempt in range(self.max_retries):
+            try:
+                conn = sqlite3.connect(self.db_path, timeout=30.0, check_same_thread=False)
+                conn.execute('PRAGMA journal_mode=WAL')
+                conn.execute('PRAGMA synchronous=NORMAL')
+                conn.execute('PRAGMA cache_size=1000')
+                conn.execute('PRAGMA temp_store=MEMORY')
+                conn.execute('PRAGMA busy_timeout=30000')
+                conn.execute('PRAGMA foreign_keys=ON')
+                return conn
+            except sqlite3.OperationalError as e:
+                if "database is locked" in str(e) and attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay * (2 ** attempt))
+                    continue
+                raise
+        raise sqlite3.OperationalError("Failed to acquire connection after retries")
+
+    def _execute_with_retry(self, query: str, params: Optional[tuple] = None, commit: bool = False) -> Optional[List[Tuple]]:
+        for attempt in range(self.max_retries):
+            try:
+                with self._get_connection() as conn:
+                    c = conn.cursor()
+                    if params:
+                        c.execute(query, params)
+                    else:
+                        c.execute(query)
+                    result = c.fetchall() if query.strip().upper().startswith('SELECT') else None
+                    if commit:
+                        conn.commit()
+                    return result
+            except sqlite3.OperationalError as e:
+                if "database is locked" in str(e) and attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay * (2 ** attempt))
+                    continue
+                raise
+        raise sqlite3.OperationalError("Query failed after retries")
+
+    # ================================================================
+    # INICIALIZAÇÃO + MIGRAÇÃO AUTOMÁTICA
+    # ================================================================
+
+    def _init_db(self):
+        with self._get_connection() as conn:
+            c = conn.cursor()
+
+            # Tabelas principais
+            c.executescript('''
+                -- aprendizado (simples)
+                CREATE TABLE IF NOT EXISTS aprendizado (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    usuario TEXT,
+                    dado TEXT,
+                    valor TEXT
+                );
+
+                -- exemplos
+                CREATE TABLE IF NOT EXISTS exemplos (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    tipo TEXT NOT NULL,
+                    entrada TEXT NOT NULL,
+                    resposta TEXT NOT NULL
+                );
+
+                -- info_geral
+                CREATE TABLE IF NOT EXISTS info_geral (
+                    chave TEXT PRIMARY KEY,
+                    valor TEXT NOT NULL
+                );
+
+                -- estilos
+                CREATE TABLE IF NOT EXISTS estilos (
+                    numero_usuario TEXT PRIMARY KEY,
+                    estilo TEXT NOT NULL
+                );
+
+                -- preferencias_tom
+                CREATE TABLE IF NOT EXISTS preferencias_tom (
+                    numero_usuario TEXT PRIMARY KEY,
+                    tom TEXT NOT NULL
+                );
+
+                -- afinidades
+                CREATE TABLE IF NOT EXISTS afinidades (
+                    numero_usuario TEXT PRIMARY KEY,
+                    afinidade REAL NOT NULL
+                );
+
+                -- termos
+                CREATE TABLE IF NOT EXISTS termos (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT NOT NULL,
+                    termo TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- aprendizados (detalhado)
+                CREATE TABLE IF NOT EXISTS aprendizados (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT NOT NULL,
+                    chave TEXT NOT NULL,
+                    valor TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- vocabulário patenteado
+                CREATE TABLE IF NOT EXISTS vocabulario_patenteado (
+                    termo TEXT PRIMARY KEY,
+                    definicao TEXT NOT NULL,
+                    uso TEXT NOT NULL,
+                    exemplo TEXT NOT NULL
+                );
+
+                -- usuarios privilegiados
+                CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
+                    numero_usuario TEXT PRIMARY KEY,
+                    nome TEXT NOT NULL
+                );
+
+                -- whatsapp_ids
+                CREATE TABLE IF NOT EXISTS whatsapp_ids (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    whatsapp_id TEXT NOT NULL,
+                    sender_number TEXT NOT NULL,
+                    UNIQUE (whatsapp_id, sender_number)
+                );
+
+                -- embeddings
+                CREATE TABLE IF NOT EXISTS embeddings (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    texto TEXT NOT NULL,
+                    embedding BLOB NOT NULL
+                );
+
+                -- mensagens
+                CREATE TABLE IF NOT EXISTS mensagens (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    usuario TEXT NOT NULL,
+                    mensagem TEXT NOT NULL,
+                    resposta TEXT NOT NULL,
+                    numero TEXT,
+                    is_reply BOOLEAN DEFAULT 0,
+                    mensagem_original TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    data TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- emocao_exemplos
+                CREATE TABLE IF NOT EXISTS emocao_exemplos (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    emocao TEXT NOT NULL,
+                    entrada TEXT NOT NULL,
+                    resposta TEXT NOT NULL,
+                    tom TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- girias_aprendidas
+                CREATE TABLE IF NOT EXISTS girias_aprendidas (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT NOT NULL,
+                    giria TEXT NOT NULL,
+                    significado TEXT NOT NULL,
+                    contexto TEXT,
+                    frequencia INTEGER DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- tom_usuario
+                CREATE TABLE IF NOT EXISTS tom_usuario (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT NOT NULL,
+                    tom_detectado TEXT NOT NULL,
+                    intensidade REAL DEFAULT 0.5,
+                    contexto TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+
+                -- adaptacao_dinamica
+                CREATE TABLE IF NOT EXISTS adaptacao_dinamica (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    numero_usuario TEXT NOT NULL,
+                    tipo_adaptacao TEXT NOT NULL,
+                    valor_anterior TEXT,
+                    valor_novo TEXT,
+                    razao TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+            ''')
+
+            conn.commit()
+
+    def _ensure_all_columns_and_indexes(self):
+        """Garante que TODAS as colunas existam + cria índices para performance"""
+        with self._get_connection() as conn:
+            c = conn.cursor()
+
+            # --- MIGRAÇÃO AUTOMÁTICA DE COLUNAS ---
+            migrations = {
+                'mensagens': [
+                    ("numero", "TEXT"),
+                    ("is_reply", "BOOLEAN DEFAULT 0"),
+                    ("mensagem_original", "TEXT"),
+                    ("created_at", "TIMESTAMP DEFAULT CURRENT_TIMESTAMP"),
+                    ("data", "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
+                ],
+                'girias_aprendidas': [
+                    ("contexto", "TEXT"),
+                    ("frequencia", "INTEGER DEFAULT 1"),
+                    ("updated_at", "TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
+                ],
+                'tom_usuario': [
+                    ("intensidade", "REAL DEFAULT 0.5"),
+                    ("contexto", "TEXT")
+                ]
+            }
+
+            for table, cols in migrations.items():
+                c.execute(f"PRAGMA table_info('{table}')")
+                existing = {row[1] for row in c.fetchall()}
+                for col_name, col_def in cols:
+                    if col_name not in existing:
+                        try:
+                            c.execute(f"ALTER TABLE {table} ADD COLUMN {col_name} {col_def}")
+                            logger.info(f"Coluna '{col_name}' adicionada em '{table}'")
+                        except Exception as e:
+                            logger.warning(f"Erro ao adicionar coluna {col_name}: {e}")
+
+            # --- ÍNDICES PARA PERFORMANCE ---
+            indexes = [
+                "CREATE INDEX IF NOT EXISTS idx_mensagens_numero ON mensagens(numero);",
+                "CREATE INDEX IF NOT EXISTS idx_mensagens_created ON mensagens(created_at DESC);",
+                "CREATE INDEX IF NOT EXISTS idx_girias_usuario ON girias_aprendidas(numero_usuario);",
+                "CREATE INDEX IF NOT EXISTS idx_girias_giria ON girias_aprendidas(giria);",
+                "CREATE INDEX IF NOT EXISTS idx_tom_usuario ON tom_usuario(numero_usuario);",
+                "CREATE INDEX IF NOT EXISTS idx_aprendizados_usuario ON aprendizados(numero_usuario);",
+                "CREATE INDEX IF NOT EXISTS idx_embeddings_texto ON embeddings(texto);"
+            ]
+
+            for idx in indexes:
+                try:
+                    c.execute(idx)
+                except:
+                    pass
+
+            conn.commit()
+
+    # ================================================================
+    # MÉTODOS PRINCIPAIS (mantidos e otimizados)
+    # ================================================================
+
+    # --- EXEMPLOS ---
+    def inserir_exemplo(self, tipo, entrada, resposta):
+        self._execute_with_retry("INSERT INTO exemplos (tipo, entrada, resposta) VALUES (?, ?, ?)", (tipo, entrada, resposta), commit=True)
+
+    def recuperar_exemplos(self, tipo=None):
+        if tipo:
+            return self._execute_with_retry("SELECT entrada, resposta FROM exemplos WHERE tipo=? ORDER BY id DESC", (tipo,))
+        return self._execute_with_retry("SELECT entrada, resposta FROM exemplos ORDER BY id DESC")
+
+    # --- INFO_GERAL ---
+    def salvar_info_geral(self, chave, valor):
+        self._execute_with_retry("INSERT OR REPLACE INTO info_geral (chave, valor) VALUES (?, ?)", (chave, valor), commit=True)
+
+    def recuperar_info_geral(self, chave):
+        result = self._execute_with_retry("SELECT valor FROM info_geral WHERE chave=?", (chave,))
+        return result[0][0] if result else None
+
+    # --- ESTILOS ---
+    def salvar_estilo(self, numero_usuario, estilo):
+        self._execute_with_retry("INSERT OR REPLACE INTO estilos (numero_usuario, estilo) VALUES (?, ?)", (numero_usuario, estilo), commit=True)
+
+    def recuperar_estilo(self, numero_usuario):
+        result = self._execute_with_retry("SELECT estilo FROM estilos WHERE numero_usuario=?", (numero_usuario,))
+        return result[0][0] if result else None
+
+    # --- PREFERENCIAS_TOM ---
+    def salvar_preferencia_tom(self, numero_usuario, tom):
+        self._execute_with_retry("INSERT OR REPLACE INTO preferencias_tom (numero_usuario, tom) VALUES (?, ?)", (numero_usuario, tom), commit=True)
+
+    def recuperar_preferencia_tom(self, numero_usuario):
+        result = self._execute_with_retry("SELECT tom FROM preferencias_tom WHERE numero_usuario=?", (numero_usuario,))
+        return result[0][0] if result else None
+
+    # --- AFINIDADES ---
+    def salvar_afinidade(self, numero_usuario, afinidade):
+        self._execute_with_retry("INSERT OR REPLACE INTO afinidades (numero_usuario, afinidade) VALUES (?, ?)", (numero_usuario, afinidade), commit=True)
+
+    def recuperar_afinidade(self, numero_usuario):
+        result = self._execute_with_retry("SELECT afinidade FROM afinidades WHERE numero_usuario=?", (numero_usuario,))
+        return result[0][0] if result else None
+
+    # --- TERMOS ---
+    def registrar_termo(self, numero_usuario, termo):
+        self._execute_with_retry("INSERT INTO termos (numero_usuario, termo) VALUES (?, ?)", (numero_usuario, termo), commit=True)
+
+    def recuperar_termos(self, numero_usuario):
+        result = self._execute_with_retry("SELECT termo FROM termos WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
+        return [row[0] for row in result] if result else []
+
+    # --- APRENDIZADOS DETALHADOS ---
+    def salvar_aprendizado_detalhado(self, numero_usuario, chave, valor):
+        self._execute_with_retry("INSERT INTO aprendizados (numero_usuario, chave, valor) VALUES (?, ?, ?)", (numero_usuario, chave, valor), commit=True)
+
+    def recuperar_aprendizado_detalhado(self, numero_usuario, chave=None):
+        if chave:
+            result = self._execute_with_retry("SELECT valor FROM aprendizados WHERE numero_usuario=? AND chave=? ORDER BY created_at DESC LIMIT 1", (numero_usuario, chave))
+            return result[0][0] if result else None
+        return self._execute_with_retry("SELECT chave, valor FROM aprendizados WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
+
+    # --- VOCABULÁRIO PATENTEADO ---
+    def registrar_vocabulario_patenteado(self, termo, definicao, uso, exemplo):
+        self._execute_with_retry("INSERT OR REPLACE INTO vocabulario_patenteado (termo, definicao, uso, exemplo) VALUES (?, ?, ?, ?)", (termo, definicao, uso, exemplo), commit=True)
+
+    def recuperar_vocabulario_patenteado(self, termo):
+        result = self._execute_with_retry("SELECT definicao, uso, exemplo FROM vocabulario_patenteado WHERE termo=?", (termo,))
+        return result[0] if result else None
+
+    # --- USUÁRIOS PRIVILEGIADOS ---
+    def adicionar_usuario_privilegiado(self, numero_usuario, nome):
+        self._execute_with_retry("INSERT OR REPLACE INTO usuarios_privilegiados (numero_usuario, nome) VALUES (?, ?)", (numero_usuario, nome), commit=True)
+
+    def verificar_usuario_privilegiado(self, numero_usuario):
+        result = self._execute_with_retry("SELECT nome FROM usuarios_privilegiados WHERE numero_usuario=?", (numero_usuario,))
+        return result[0][0] if result else None
+
+    # --- WHATSAPP IDS ---
+    def registrar_whatsapp_id(self, whatsapp_id, sender_number):
+        self._execute_with_retry("INSERT OR IGNORE INTO whatsapp_ids (whatsapp_id, sender_number) VALUES (?, ?)", (whatsapp_id, sender_number), commit=True)
+
+    def recuperar_whatsapp_ids(self, sender_number):
+        result = self._execute_with_retry("SELECT whatsapp_id FROM whatsapp_ids WHERE sender_number=?", (sender_number,))
+        return [row[0] for row in result] if result else []
+
+    # --- EMBEDDINGS ---
+    def salvar_embedding(self, texto, embedding_bytes):
+        self._execute_with_retry("INSERT INTO embeddings (texto, embedding) VALUES (?, ?)", (texto, embedding_bytes), commit=True)
+
+    def recuperar_embedding(self, texto):
+        result = self._execute_with_retry("SELECT embedding FROM embeddings WHERE texto=? ORDER BY id DESC LIMIT 1", (texto,))
+        return result[0][0] if result else None
+
+    # --- MENSAGENS ---
+    def salvar_mensagem(self, usuario, mensagem, resposta, numero=None, is_reply=False, mensagem_original=None):
+        try:
+            cols = ['usuario', 'mensagem', 'resposta']
+            vals = [usuario, mensagem, resposta]
+            if numero: cols.append('numero'); vals.append(numero)
+            if is_reply is not None: cols.append('is_reply'); vals.append(int(is_reply))
+            if mensagem_original: cols.append('mensagem_original'); vals.append(mensagem_original)
+
+            placeholders = ', '.join(['?' for _ in cols])
+            query = f"INSERT INTO mensagens ({', '.join(cols)}) VALUES ({placeholders})"
+            self._execute_with_retry(query, tuple(vals), commit=True)
+        except Exception as e:
+            logger.warning(f"Fallback salvar_mensagem: {e}")
+            self._execute_with_retry("INSERT INTO mensagens (usuario, mensagem, resposta) VALUES (?, ?, ?)", (usuario, mensagem, resposta), commit=True)
+
+    def recuperar_mensagens(self, usuario, limite=5):
+        return self._execute_with_retry("SELECT mensagem, resposta FROM mensagens WHERE usuario=? OR numero=? ORDER BY id DESC LIMIT ?", (usuario, usuario, limite))
+
+    # --- APRENDIZADO SIMPLES ---
+    def salvar_aprendizado(self, usuario, dado, valor):
+        self._execute_with_retry("INSERT INTO aprendizado (usuario, dado, valor) VALUES (?, ?, ?)", (usuario, dado, valor), commit=True)
+
+    def recuperar_aprendizado(self, usuario, dado):
+        result = self._execute_with_retry("SELECT valor FROM aprendizado WHERE usuario=? AND dado=? ORDER BY id DESC LIMIT 1", (usuario, dado))
+        return result[0][0] if result else None
+
+    # --- EMOÇÃO EXEMPLOS ---
+    def salvar_exemplo_emocao(self, emocao: str, entrada: str, resposta: str, tom: str):
+        self._execute_with_retry("INSERT INTO emocao_exemplos (emocao, entrada, resposta, tom) VALUES (?, ?, ?, ?)", (emocao, entrada, resposta, tom), commit=True)
+
+    def recuperar_exemplos_emocao(self, emocao: str) -> List[Dict[str, Any]]:
+        result = self._execute_with_retry("SELECT entrada, resposta, tom FROM emocao_exemplos WHERE emocao=? ORDER BY created_at DESC", (emocao,))
+        return [{"entrada": r[0], "resposta": r[1], "tom": r[2]} for r in result] if result else []
+
+    # --- GIRIAS APRENDIDAS ---
+    def salvar_giria_aprendida(self, numero_usuario: str, giria: str, significado: str, contexto: Optional[str] = None):
+        existing = self._execute_with_retry("SELECT id, frequencia FROM girias_aprendidas WHERE numero_usuario=? AND giria=?", (numero_usuario, giria))
+        if existing:
+            self._execute_with_retry("UPDATE girias_aprendidas SET frequencia=frequencia+1, updated_at=CURRENT_TIMESTAMP WHERE id=?", (existing[0][0],), commit=True)
+        else:
+            self._execute_with_retry("INSERT INTO girias_aprendidas (numero_usuario, giria, significado, contexto) VALUES (?, ?, ?, ?)", (numero_usuario, giria, significado, contexto), commit=True)
+
+    def recuperar_girias_usuario(self, numero_usuario: str) -> List[Dict[str, Any]]:
+        result = self._execute_with_retry("SELECT giria, significado, contexto, frequencia FROM girias_aprendidas WHERE numero_usuario=? ORDER BY frequencia DESC, updated_at DESC", (numero_usuario,))
+        return [{"giria": r[0], "significado": r[1], "contexto": r[2], "frequencia": r[3]} for r in result] if result else []
+
+    def buscar_significado_giria(self, numero_usuario: str, giria: str) -> Optional[str]:
+        result = self._execute_with_retry("SELECT significado FROM girias_aprendidas WHERE numero_usuario=? AND giria=?", (numero_usuario, giria))
+        return result[0][0] if result else None
+
+    # --- TOM USUÁRIO ---
+    def registrar_tom_usuario(self, numero_usuario: str, tom_detectado: str, intensidade: float = 0.5, contexto: Optional[str] = None):
+        self._execute_with_retry("INSERT INTO tom_usuario (numero_usuario, tom_detectado, intensidade, contexto) VALUES (?, ?, ?, ?)", (numero_usuario, tom_detectado, intensidade, contexto), commit=True)
+
+    def obter_tom_predominante(self, numero_usuario: str, limite: int = 10) -> Optional[str]:
+        result = self._execute_with_retry("""
+            SELECT tom_detectado, COUNT(*) FROM tom_usuario
+            WHERE numero_usuario=? GROUP BY tom_detectado
+            ORDER BY COUNT(*) DESC LIMIT 1
+        """, (numero_usuario,))
+        return result[0][0] if result else None
+
+    # --- ADAPTAÇÃO DINÂMICA ---
+    def registrar_adaptacao(self, numero_usuario: str, tipo_adaptacao: str, valor_anterior: str, valor_novo: str, razao: str):
+        self._execute_with_retry("INSERT INTO adaptacao_dinamica (numero_usuario, tipo_adaptacao, valor_anterior, valor_novo, razao) VALUES (?, ?, ?, ?, ?)", (numero_usuario, tipo_adaptacao, valor_anterior, valor_novo, razao), commit=True)
+
+    def obter_adaptacoes_usuario(self, numero_usuario: str, tipo_adaptacao: Optional[str] = None) -> List[Dict[str, Any]]:
+        if tipo_adaptacao:
+            result = self._execute_with_retry("SELECT tipo_adaptacao, valor_anterior, valor_novo, razao, created_at FROM adaptacao_dinamica WHERE numero_usuario=? AND tipo_adaptacao=? ORDER BY created_at DESC", (numero_usuario, tipo_adaptacao))
+        else:
+            result = self._execute_with_retry("SELECT tipo_adaptacao, valor_anterior, valor_novo, razao, created_at FROM adaptacao_dinamica WHERE numero_usuario=? ORDER BY created_at DESC", (numero_usuario,))
+        return [{"tipo": r[0], "anterior": r[1], "novo": r[2], "razao": r[3], "data": r[4]} for r in result] if result else []
+
+    # --- ANÁLISE DE EMOÇÕES ---
+    def analisar_emocoes_mensagem(self, mensagem: str) -> Dict[str, Any]:
+        msg = mensagem.lower()
+        keywords = {
+            "feliz": ["feliz", "alegre", "contente", "ótimo", "bom", "incrível", "show", "top", "fixe", "bué"],
+            "triste": ["triste", "chateado", "ruim", "péssimo", "horrível", "deprimido"],
+            "raiva": ["raiva", "puto", "irritado", "furioso", "nervoso", "merda", "caralho"],
+            "medo": ["medo", "assustado", "preocupado", "ansioso"],
+            "surpresa": ["uau", "caramba", "incrível", "surpreso"],
+            "nojo": ["nojo", "repugnante", "detesto", "odeio"],
+            "amor": ["amo", "adoro", "gosto", "apaixonado"]
+        }
+        max_count = 0
+        emocao = "neutro"
+        for e, words in keywords.items():
+            count = sum(1 for w in words if w in msg)
+            if count > max_count:
+                max_count = count
+                emocao = e
+        return {
+            "emocao": emocao,
+            "intensidade": min(max_count / 3.0, 1.0),
+            "palavras_chave_encontradas": max_count
+        }
+
+    # --- CONTEXTO COMPLETO ---
+    def obter_contexto_aprendizado(self, numero_usuario: str) -> Dict[str, Any]:
+        return {
+            "girias": self.recuperar_girias_usuario(numero_usuario),
+            "tom_predominante": self.obter_tom_predominante(numero_usuario),
+            "estilo": self.recuperar_estilo(numero_usuario),
+            "preferencia_tom": self.recuperar_preferencia_tom(numero_usuario),
+            "afinidade": self.recuperar_afinidade(numero_usuario),
+            "adaptacoes_recentes": self.obter_adaptacoes_usuario(numero_usuario)[-5:],
+            "aprendizados_detalhados": dict(self.recuperar_aprendizado_detalhado(numero_usuario) or [])
+        }