modules/database.py

# modules/database.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025) - CORREÇÃO: Com suporte a nivel_transicao, desc_transicao e usuario_privilegiado
"""
✅ TOTALMENTE ADAPTADO ao index.js atualizado
✅ CORREÇÃO: Problema com message_id UNIQUE resolvido
✅ CORREÇÃO: Suporte para nivel_transicao, desc_transicao e usuario_privilegiado adicionado
✅ Métodos corretos para api.py, contexto.py, treinamento.py
✅ Estrutura completa com reply_metadata
✅ Todos os métodos necessários implementados
"""

import sqlite3
import time
import os
import json
import hashlib
import random
from datetime import datetime
from typing import Optional, List, Dict, Any, Tuple
from loguru import logger

class Database:
    def __init__(self, db_path: str = "akira.db"):
        self.db_path = db_path
        self.max_retries = 5
        self.retry_delay = 0.1
        
        db_dir = os.path.dirname(self.db_path)
        if db_dir:
            os.makedirs(db_dir, exist_ok=True)
        
        self._init_db()
        self._ensure_columns()
        logger.info(f"✅ Database inicializado: {self.db_path}")

    def _get_connection(self) -> sqlite3.Connection:
        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=2000')
        return conn

    def _execute_with_retry(self, query: str, params: Optional[tuple] = None,
                           commit: bool = False, fetch: bool = True):
        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)
                    
                    if commit:
                        conn.commit()
                    
                    if fetch and query.strip().upper().startswith('SELECT'):
                        return c.fetchall()
                    elif fetch:
                        return c.fetchall() if c.description else []
                    else:
                        return c.lastrowid
            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
                logger.error(f"Erro SQL: {e}")
                raise
            except Exception as e:
                logger.error(f"Erro na query: {e}")
                raise

    def _init_db(self):
        """Cria todas as tabelas necessárias - CORREÇÃO: message_id sem UNIQUE"""
        try:
            with self._get_connection() as conn:
                c = conn.cursor()
                
                # Tabela principal de mensagens - CORREÇÃO: message_id sem UNIQUE
                c.execute('''
                    CREATE TABLE IF NOT EXISTS mensagens (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        usuario TEXT NOT NULL,
                        usuario_nome TEXT DEFAULT '',
                        numero TEXT NOT NULL,
                        mensagem TEXT NOT NULL,
                        resposta TEXT NOT NULL,
                        contexto_id TEXT NOT NULL,
                        tipo_contexto TEXT DEFAULT 'pv',
                        tipo_conversa TEXT DEFAULT 'pv',
                        tipo_mensagem TEXT DEFAULT 'texto',
                        
                        -- Reply info
                        is_reply BOOLEAN DEFAULT 0,
                        mensagem_original TEXT,
                        mensagem_citada_limpa TEXT,
                        reply_to_bot BOOLEAN DEFAULT 0,
                        reply_info_json TEXT,
                        
                        -- Estado
                        humor TEXT DEFAULT 'normal_ironico',
                        modo_resposta TEXT DEFAULT 'normal_ironico',
                        emocao_detectada TEXT,
                        confianca_emocao REAL DEFAULT 0.5,
                        
                        -- Transição
                        nivel_transicao INTEGER DEFAULT 0,
                        info_transicao_json TEXT,
                        usuario_privilegiado BOOLEAN DEFAULT 0,
                        
                        -- Grupo
                        grupo_id TEXT DEFAULT '',
                        grupo_nome TEXT DEFAULT '',
                        
                        -- Audio
                        audio_transcricao TEXT,
                        fonte_stt TEXT DEFAULT 'deepgram',
                        confianca_stt REAL DEFAULT 0.0,
                        
                        -- Meta
                        comando_executado TEXT,
                        has_media BOOLEAN DEFAULT 0,
                        media_type TEXT DEFAULT '',
                        message_id TEXT,
                        bot_response_time_ms INTEGER DEFAULT 0,
                        is_mention BOOLEAN DEFAULT 0,
                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                        deletado BOOLEAN DEFAULT 0
                    )
                ''')
                
                # Índice para message_id para performance (sem UNIQUE)
                c.execute('''
                    CREATE INDEX IF NOT EXISTS idx_mensagens_message_id 
                    ON mensagens(message_id)
                ''')
                
                # Índice para busca por número
                c.execute('''
                    CREATE INDEX IF NOT EXISTS idx_mensagens_numero 
                    ON mensagens(numero)
                ''')
                
                # Índice para usuario_privilegiado
                c.execute('''
                    CREATE INDEX IF NOT EXISTS idx_mensagens_usuario_privilegiado 
                    ON mensagens(usuario_privilegiado)
                ''')
                
                # Usuários privilegiados
                c.execute('''
                    CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT UNIQUE NOT NULL,
                        nome TEXT NOT NULL,
                        nome_curto TEXT,
                        tom_inicial TEXT DEFAULT 'formal',
                        pode_dar_ordens BOOLEAN DEFAULT 0,
                        pode_usar_reset BOOLEAN DEFAULT 0,
                        pode_forcar_modo BOOLEAN DEFAULT 0,
                        pode_apagar_mensagens BOOLEAN DEFAULT 0,
                        pode_moderar_grupos BOOLEAN DEFAULT 0,
                        nivel_acesso TEXT DEFAULT 'vip',
                        ultimo_comando TEXT,
                        timestamp_comando DATETIME,
                        comandos_executados INTEGER DEFAULT 0,
                        comandos_falhos INTEGER DEFAULT 0,
                        config_personalizada TEXT DEFAULT '{}',
                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Contexto
                c.execute('''
                    CREATE TABLE IF NOT EXISTS contexto (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT UNIQUE NOT NULL,
                        contexto_id TEXT NOT NULL,
                        tipo_contexto TEXT DEFAULT 'pv',
                        historico TEXT,
                        humor_atual TEXT DEFAULT 'normal_ironico',
                        modo_resposta TEXT DEFAULT 'normal_ironico',
                        nivel_transicao INTEGER DEFAULT 0,
                        info_transicao_json TEXT,
                        usuario_privilegiado BOOLEAN DEFAULT 0,
                        humor_alvo TEXT DEFAULT 'normal_ironico',
                        termos TEXT,
                        girias TEXT,
                        tom TEXT DEFAULT 'normal',
                        emocao_tendencia TEXT DEFAULT 'neutral',
                        volatilidade REAL DEFAULT 0.5,
                        nome_usuario TEXT DEFAULT '',
                        ultima_mensagem_audio BOOLEAN DEFAULT 0,
                        frequencia_audio INTEGER DEFAULT 0,
                        prefere_audio BOOLEAN DEFAULT 0,
                        nivel_confianca_stt REAL DEFAULT 0.0,
                        configuracao_reply TEXT DEFAULT '{}',
                        estatisticas_interacao TEXT DEFAULT '{}',
                        ultimo_contato DATETIME,
                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Training examples
                c.execute('''
                    CREATE TABLE IF NOT EXISTS training_examples (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        input_text TEXT NOT NULL,
                        output_text TEXT NOT NULL,
                        humor TEXT DEFAULT 'normal_ironico',
                        modo_resposta TEXT DEFAULT 'normal_ironico',
                        nivel_transicao INTEGER DEFAULT 0,
                        usuario_privilegiado BOOLEAN DEFAULT 0,
                        emocao_contexto TEXT,
                        contexto_super_claro TEXT,
                        tipo_interacao TEXT DEFAULT 'normal',
                        score_relevancia REAL DEFAULT 1.0,
                        tags TEXT DEFAULT '',
                        qualidade_score REAL DEFAULT 1.0,
                        usado BOOLEAN DEFAULT 0,
                        usado_para_finetuning BOOLEAN DEFAULT 0,
                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Transições de humor
                c.execute('''
                    CREATE TABLE IF NOT EXISTS transicoes_humor (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT NOT NULL,
                        contexto_id TEXT NOT NULL,
                        humor_anterior TEXT NOT NULL,
                        humor_novo TEXT NOT NULL,
                        nivel_transicao_anterior INTEGER DEFAULT 0,
                        nivel_transicao_novo INTEGER DEFAULT 0,
                        usuario_privilegiado BOOLEAN DEFAULT 0,
                        emocao_trigger TEXT,
                        confianca_emocao REAL,
                        razao TEXT,
                        intensidade REAL DEFAULT 0.5,
                        contexto_mensagem TEXT,
                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Gírias
                c.execute('''
                    CREATE TABLE IF NOT EXISTS girias_aprendidas (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT NOT NULL,
                        contexto_id TEXT NOT NULL,
                        giria TEXT NOT NULL,
                        significado TEXT NOT NULL,
                        contexto TEXT,
                        frequencia INTEGER DEFAULT 1,
                        ultimo_uso DATETIME DEFAULT CURRENT_TIMESTAMP,
                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
                        UNIQUE(numero, giria)
                    )
                ''')
                
                # Comandos executados
                c.execute('''
                    CREATE TABLE IF NOT EXISTS comandos_executados (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT NOT NULL,
                        comando TEXT NOT NULL,
                        parametros TEXT,
                        sucesso BOOLEAN DEFAULT 1,
                        resposta TEXT,
                        tipo_conversa TEXT DEFAULT 'pv',
                        grupo_id TEXT DEFAULT '',
                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Reset log
                c.execute('''
                    CREATE TABLE IF NOT EXISTS reset_log (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT NOT NULL,
                        tipo_reset TEXT NOT NULL,
                        itens_apagados INTEGER DEFAULT 0,
                        motivo TEXT,
                        sucesso BOOLEAN DEFAULT 1,
                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                # Interações (para treinamento)
                c.execute('''
                    CREATE TABLE IF NOT EXISTS interacoes (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        numero TEXT NOT NULL,
                        mensagem TEXT NOT NULL,
                        resposta TEXT NOT NULL,
                        humor TEXT DEFAULT 'normal_ironico',
                        modo_resposta TEXT DEFAULT 'normal_ironico',
                        nivel_transicao INTEGER DEFAULT 0,
                        usuario_privilegiado BOOLEAN DEFAULT 0,
                        emocao_detectada TEXT,
                        tipo_conversa TEXT DEFAULT 'pv',
                        reply_info_json TEXT,
                        qualidade_score REAL DEFAULT 1.0,
                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP
                    )
                ''')
                
                conn.commit()
                logger.info("✅ Tabelas criadas/verificadas com suporte a nivel_transicao e usuario_privilegiado")
                
        except Exception as e:
            logger.error(f"❌ Erro ao criar tabelas: {e}")
            raise

    def _ensure_columns(self):
        """Garante que todas as colunas existam"""
        try:
            with self._get_connection() as conn:
                c = conn.cursor()
                
                # Colunas para mensagens
                novas_colunas = [
                    ("tipo_mensagem", "TEXT DEFAULT 'texto'"),
                    ("reply_info_json", "TEXT"),
                    ("usuario_nome", "TEXT DEFAULT ''"),
                    ("grupo_id", "TEXT DEFAULT ''"),
                    ("grupo_nome", "TEXT DEFAULT ''"),
                    ("audio_transcricao", "TEXT"),
                    ("fonte_stt", "TEXT DEFAULT 'deepgram'"),
                    ("confianca_stt", "REAL DEFAULT 0.0"),
                    ("comando_executado", "TEXT"),
                    ("tipo_conversa", "TEXT DEFAULT 'pv'"),
                    ("is_mention", "BOOLEAN DEFAULT 0"),
                    ("has_media", "BOOLEAN DEFAULT 0"),
                    ("media_type", "TEXT DEFAULT ''"),
                    ("message_id", "TEXT"),
                    ("bot_response_time_ms", "INTEGER DEFAULT 0"),
                    ("nivel_transicao", "INTEGER DEFAULT 0"),
                    ("info_transicao_json", "TEXT"),
                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
                ]
                
                for col_name, col_def in novas_colunas:
                    try:
                        c.execute(f"ALTER TABLE mensagens ADD COLUMN {col_name} {col_def}")
                    except sqlite3.OperationalError:
                        pass
                
                # Colunas para contexto
                contexto_colunas = [
                    ("info_transicao_json", "TEXT"),
                    ("nivel_transicao", "INTEGER DEFAULT 0"),
                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
                ]
                
                for col_name, col_def in contexto_colunas:
                    try:
                        c.execute(f"ALTER TABLE contexto ADD COLUMN {col_name} {col_def}")
                    except sqlite3.OperationalError:
                        pass
                
                # Colunas para transições
                transicoes_colunas = [
                    ("nivel_transicao_anterior", "INTEGER DEFAULT 0"),
                    ("nivel_transicao_novo", "INTEGER DEFAULT 0"),
                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
                ]
                
                for col_name, col_def in transicoes_colunas:
                    try:
                        c.execute(f"ALTER TABLE transicoes_humor ADD COLUMN {col_name} {col_def}")
                    except sqlite3.OperationalError:
                        pass
                
                # Colunas para training_examples
                training_colunas = [
                    ("nivel_transicao", "INTEGER DEFAULT 0"),
                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
                ]
                
                for col_name, col_def in training_colunas:
                    try:
                        c.execute(f"ALTER TABLE training_examples ADD COLUMN {col_name} {col_def}")
                    except sqlite3.OperationalError:
                        pass
                
                # Colunas para interacoes
                interacoes_colunas = [
                    ("usuario_privilegiado", "BOOLEAN DEFAULT 0")
                ]
                
                for col_name, col_def in interacoes_colunas:
                    try:
                        c.execute(f"ALTER TABLE interacoes ADD COLUMN {col_name} {col_def}")
                    except sqlite3.OperationalError:
                        pass
                
                conn.commit()
                
        except Exception as e:
            logger.warning(f"⚠️ Erro ao verificar colunas: {e}")

    # ========================================================================
    # MÉTODOS DE SALVAMENTO (ADAPTADOS AO INDEX.JS) - CORRIGIDOS COM TODOS PARÂMETROS
    # ========================================================================
    
    def salvar_mensagem(self, usuario: str, mensagem: str, resposta: str,
                       numero: str = '', is_reply: bool = False,
                       mensagem_original: str = None,
                       mensagem_citada_limpa: str = None,
                       reply_to_bot: bool = False,
                       humor: str = 'normal_ironico',
                       modo_resposta: str = 'normal_ironico',
                       emocao_detectada: str = None,
                       confianca_emocao: float = 0.5,
                       nivel_transicao: int = 0,
                       info_transicao: dict = None,
                       desc_transicao: str = None,
                       usuario_privilegiado: bool = False,  # NOVO PARÂMETRO ADICIONADO
                       tipo_mensagem: str = 'texto',
                       reply_info_json: str = None,
                       usuario_nome: str = '',
                       grupo_id: str = '',
                       grupo_nome: str = '',
                       tipo_conversa: str = 'pv',
                       audio_transcricao: str = None,
                       fonte_stt: str = 'deepgram',
                       confianca_stt: float = 0.0,
                       comando_executado: str = None,
                       has_media: bool = False,
                       media_type: str = '',
                       message_id: str = None,
                       bot_response_time_ms: int = 0,
                       is_mention: bool = False) -> bool:
        """Salva mensagem no banco - COM SUPORTE A TODOS PARÂMETROS"""
        try:
            numero_final = str(numero or usuario).strip()
            contexto_id = self._gerar_contexto_id(numero_final, tipo_conversa)
            
            # Converte reply_info para JSON se for dict
            if isinstance(reply_info_json, dict):
                reply_info_json = json.dumps(reply_info_json, ensure_ascii=False)
            
            # Converte info_transicao para JSON se for dict
            info_transicao_json = None
            if info_transicao:
                info_transicao_json = json.dumps(info_transicao, ensure_ascii=False)
            
            # Se desc_transicao for fornecida, adiciona ao info_transicao
            if desc_transicao:
                if info_transicao_json:
                    try:
                        info_transicao_dict = json.loads(info_transicao_json) if isinstance(info_transicao_json, str) else info_transicao_json
                        info_transicao_dict['desc_transicao'] = desc_transicao
                        info_transicao_json = json.dumps(info_transicao_dict, ensure_ascii=False)
                    except:
                        # Cria novo info_transicao se não conseguir parsear
                        info_transicao_json = json.dumps({'desc_transicao': desc_transicao}, ensure_ascii=False)
                else:
                    # Cria info_transicao com desc_transicao
                    info_transicao_json = json.dumps({'desc_transicao': desc_transicao}, ensure_ascii=False)
            
            # Gera message_id único se não fornecido
            if not message_id:
                timestamp = int(time.time() * 1000)
                random_suffix = random.randint(1000, 9999)
                message_id = f"{numero_final}_{timestamp}_{random_suffix}"
            
            # Adiciona um sufixo aleatório extra para garantir unicidade
            unique_suffix = random.randint(100, 999)
            message_id = f"{message_id}_{unique_suffix}"
            
            try:
                self._execute_with_retry(
                    """
                    INSERT INTO mensagens
                    (usuario, usuario_nome, mensagem, resposta, numero, contexto_id, tipo_contexto,
                     tipo_conversa, tipo_mensagem, is_reply, mensagem_original, mensagem_citada_limpa,
                     reply_to_bot, reply_info_json, humor, modo_resposta, emocao_detectada, 
                     confianca_emocao, nivel_transicao, info_transicao_json, usuario_privilegiado,
                     grupo_id, grupo_nome, audio_transcricao, fonte_stt, confianca_stt, comando_executado, 
                     has_media, media_type, message_id, bot_response_time_ms, is_mention)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                    """,
                    (
                        usuario[:50], usuario_nome[:100] or usuario[:100], 
                        mensagem[:4000], resposta[:4000], numero_final,
                        contexto_id, tipo_conversa, tipo_conversa, tipo_mensagem,
                        int(is_reply), mensagem_original, mensagem_citada_limpa,
                        int(reply_to_bot), reply_info_json, humor, modo_resposta,
                        emocao_detectada, confianca_emocao, nivel_transicao,
                        info_transicao_json, int(usuario_privilegiado),  # ADICIONADO
                        grupo_id[:50], grupo_nome[:100],
                        audio_transcricao[:2000] if audio_transcricao else None,
                        fonte_stt[:50], confianca_stt, comando_executado[:100] if comando_executado else None,
                        int(has_media), media_type[:50], message_id[:200],
                        bot_response_time_ms, int(is_mention)
                    ),
                    commit=True,
                    fetch=False
                )
                
                logger.debug(f"✅ Mensagem salva: {numero_final} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
                return True
                
            except sqlite3.IntegrityError as e:
                # CORREÇÃO: Se ainda houver erro de UNIQUE (pode ser de outra coluna)
                if "UNIQUE constraint failed" in str(e):
                    logger.warning(f"🔄 Erro de UNIQUE, gerando novo message_id")
                    # Gera um novo message_id completamente diferente
                    new_message_id = f"{numero_final}_{int(time.time() * 1000)}_{random.randint(10000, 99999)}"
                    
                    self._execute_with_retry(
                        """
                        INSERT INTO mensagens
                        (usuario, usuario_nome, mensagem, resposta, numero, contexto_id, tipo_contexto,
                         tipo_conversa, tipo_mensagem, is_reply, mensagem_original, mensagem_citada_limpa,
                         reply_to_bot, reply_info_json, humor, modo_resposta, emocao_detectada, 
                         confianca_emocao, nivel_transicao, info_transicao_json, usuario_privilegiado,
                         grupo_id, grupo_nome, audio_transcricao, fonte_stt, confianca_stt, comando_executado, 
                         has_media, media_type, message_id, bot_response_time_ms, is_mention)
                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                        """,
                        (
                            usuario[:50], usuario_nome[:100] or usuario[:100], 
                            mensagem[:4000], resposta[:4000], numero_final,
                            contexto_id, tipo_conversa, tipo_conversa, tipo_mensagem,
                            int(is_reply), mensagem_original, mensagem_citada_limpa,
                            int(reply_to_bot), reply_info_json, humor, modo_resposta,
                            emocao_detectada, confianca_emocao, nivel_transicao,
                            info_transicao_json, int(usuario_privilegiado),  # ADICIONADO
                            grupo_id[:50], grupo_nome[:100],
                            audio_transcricao[:2000] if audio_transcricao else None,
                            fonte_stt[:50], confianca_stt, comando_executado[:100] if comando_executado else None,
                            int(has_media), media_type[:50], new_message_id[:200],
                            bot_response_time_ms, int(is_mention)
                        ),
                        commit=True,
                        fetch=False
                    )
                    logger.debug(f"✅ Mensagem salva com novo message_id: {new_message_id}")
                    return True
                else:
                    raise
            
        except Exception as e:
            logger.error(f"❌ Erro ao salvar mensagem: {e}")
            return False

    def salvar_training_example(self, input_text: str, output_text: str,
                               humor: str = "normal_ironico",
                               modo_resposta: str = "normal_ironico",
                               nivel_transicao: int = 0,
                               usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
                               emocao_contexto: str = None,
                               qualidade_score: float = 1.0,
                               contexto_super_claro: Dict = None,
                               tipo_interacao: str = "normal",
                               score_relevancia: float = 1.0,
                               tags: List[str] = None) -> bool:
        """Salva exemplo de treinamento - COM usuario_privilegiado"""
        try:
            contexto_json = json.dumps(contexto_super_claro, ensure_ascii=False) if contexto_super_claro else None
            tags_str = ",".join(tags) if tags else ""
            
            self._execute_with_retry(
                """
                INSERT INTO training_examples
                (input_text, output_text, humor, modo_resposta, nivel_transicao,
                 usuario_privilegiado, emocao_contexto, qualidade_score, contexto_super_claro, 
                 tipo_interacao, score_relevancia, tags)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    input_text[:2000], output_text[:2000], humor, modo_resposta,
                    nivel_transicao, int(usuario_privilegiado), emocao_contexto, 
                    qualidade_score, contexto_json, tipo_interacao, score_relevancia, 
                    tags_str[:200]
                ),
                commit=True,
                fetch=False
            )
            logger.debug(f"✅ Training example salvo | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
            return True
        except Exception as e:
            logger.error(f"❌ Erro ao salvar training: {e}")
            return False

    def salvar_transicao_humor(self, numero: str, humor_anterior: str,
                              humor_novo: str, nivel_transicao_anterior: int = 0,
                              nivel_transicao_novo: int = 0,
                              usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
                              emocao_trigger: str = None,
                              confianca_emocao: float = 0.5,
                              razao: str = "", intensidade: float = 0.5,
                              contexto_mensagem: str = None):
        """Salva transição de humor - COM usuario_privilegiado"""
        try:
            contexto_id = self._gerar_contexto_id(numero, 'auto')
            
            self._execute_with_retry(
                """
                INSERT INTO transicoes_humor
                (numero, contexto_id, humor_anterior, humor_novo, 
                 nivel_transicao_anterior, nivel_transicao_novo, usuario_privilegiado,
                 emocao_trigger, confianca_emocao, razao, intensidade, contexto_mensagem)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    str(numero).strip(), contexto_id, humor_anterior, humor_novo,
                    nivel_transicao_anterior, nivel_transicao_novo, int(usuario_privilegiado),
                    emocao_trigger, confianca_emocao, razao[:200], intensidade, 
                    contexto_mensagem[:500] if contexto_mensagem else None
                ),
                commit=True,
                fetch=False
            )
            logger.debug(f"🎭 Transição salva: {humor_anterior}→{humor_novo} | Nível: {nivel_transicao_anterior}→{nivel_transicao_novo} | Privilegiado: {usuario_privilegiado}")
        except Exception as e:
            logger.error(f"❌ Erro ao salvar transição: {e}")

    def salvar_giria(self, numero: str, giria: str, significado: str, contexto: str = ""):
        """Salva gíria aprendida"""
        try:
            numero_final = str(numero).strip()
            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
            
            result = self._execute_with_retry(
                "SELECT id, frequencia FROM girias_aprendidas WHERE numero = ? AND giria = ?",
                (numero_final, giria),
                fetch=True
            )
            
            if result:
                self._execute_with_retry(
                    """
                    UPDATE girias_aprendidas
                    SET frequencia = frequencia + 1,
                        ultimo_uso = CURRENT_TIMESTAMP
                    WHERE numero = ? AND giria = ?
                    """,
                    (numero_final, giria),
                    commit=True,
                    fetch=False
                )
            else:
                self._execute_with_retry(
                    """
                    INSERT INTO girias_aprendidas
                    (numero, contexto_id, giria, significado, contexto)
                    VALUES (?, ?, ?, ?, ?)
                    """,
                    (numero_final, contexto_id, giria, significado, contexto[:100]),
                    commit=True,
                    fetch=False
                )
            return True
        except Exception as e:
            logger.error(f"❌ Erro ao salvar gíria: {e}")
            return False

    # ========================================================================
    # MÉTODOS DE CONTEXTO - COM usuario_privilegiado
    # ========================================================================
    
    def atualizar_contexto(self, numero: str, humor_atual: str = None,
                          modo_resposta: str = None, nivel_transicao: int = None,
                          info_transicao: dict = None, usuario_privilegiado: bool = False,
                          tom: str = None, emocao_tendencia: str = None) -> bool:
        """Atualiza contexto do usuário - COM usuario_privilegiado"""
        try:
            numero_final = str(numero).strip()
            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
            
            # Verifica se contexto existe
            result = self._execute_with_retry(
                "SELECT 1 FROM contexto WHERE numero = ?",
                (numero_final,),
                fetch=True
            )
            
            info_transicao_json = None
            if info_transicao:
                info_transicao_json = json.dumps(info_transicao, ensure_ascii=False)
            
            if result:
                # Atualiza existente
                updates = []
                params = []
                
                if humor_atual:
                    updates.append("humor_atual = ?")
                    params.append(humor_atual)
                if modo_resposta:
                    updates.append("modo_resposta = ?")
                    params.append(modo_resposta)
                if nivel_transicao is not None:
                    updates.append("nivel_transicao = ?")
                    params.append(nivel_transicao)
                if info_transicao_json:
                    updates.append("info_transicao_json = ?")
                    params.append(info_transicao_json)
                updates.append("usuario_privilegiado = ?")
                params.append(int(usuario_privilegiado))
                if tom:
                    updates.append("tom = ?")
                    params.append(tom)
                if emocao_tendencia:
                    updates.append("emocao_tendencia = ?")
                    params.append(emocao_tendencia)
                
                updates.append("ultimo_contato = CURRENT_TIMESTAMP")
                updates.append("data_atualizacao = CURRENT_TIMESTAMP")
                
                if updates:
                    query = f"UPDATE contexto SET {', '.join(updates)} WHERE numero = ?"
                    params.append(numero_final)
                    self._execute_with_retry(query, tuple(params), commit=True, fetch=False)
            else:
                # Cria novo contexto
                self._execute_with_retry(
                    """
                    INSERT INTO contexto
                    (numero, contexto_id, humor_atual, modo_resposta, nivel_transicao,
                     info_transicao_json, usuario_privilegiado, tom, emocao_tendencia, ultimo_contato)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
                    """,
                    (
                        numero_final, contexto_id,
                        humor_atual or 'normal_ironico',
                        modo_resposta or 'normal_ironico',
                        nivel_transicao or 0,
                        info_transicao_json,
                        int(usuario_privilegiado),
                        tom or 'normal',
                        emocao_tendencia or 'neutral'
                    ),
                    commit=True,
                    fetch=False
                )
            
            logger.debug(f"✅ Contexto atualizado: {numero_final} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erro ao atualizar contexto: {e}")
            return False

    def recuperar_contexto(self, numero: str) -> Dict[str, Any]:
        """Recupera contexto completo do usuário"""
        try:
            result = self._execute_with_retry(
                """
                SELECT humor_atual, modo_resposta, nivel_transicao, info_transicao_json,
                       usuario_privilegiado, tom, emocao_tendencia, ultimo_contato
                FROM contexto WHERE numero = ?
                """,
                (str(numero).strip(),),
                fetch=True
            )
            
            if result:
                row = result[0]
                info_transicao = {}
                if row[3]:
                    try:
                        info_transicao = json.loads(row[3])
                    except:
                        pass
                
                return {
                    "humor_atual": row[0] or "normal_ironico",
                    "modo_resposta": row[1] or "normal_ironico",
                    "nivel_transicao": row[2] or 0,
                    "info_transicao": info_transicao,
                    "usuario_privilegiado": bool(row[4]) if row[4] is not None else False,
                    "tom": row[5] or "normal",
                    "emocao_tendencia": row[6] or "neutral",
                    "ultimo_contato": row[7]
                }
            
            return {
                "humor_atual": "normal_ironico",
                "modo_resposta": "normal_ironico",
                "nivel_transicao": 0,
                "info_transicao": {},
                "usuario_privilegiado": False,
                "tom": "normal",
                "emocao_tendencia": "neutral",
                "ultimo_contato": None
            }
            
        except Exception as e:
            logger.error(f"❌ Erro ao recuperar contexto: {e}")
            return {}

    # ========================================================================
    # MÉTODOS DE RECUPERAÇÃO
    # ========================================================================
    
    def recuperar_mensagens(self, numero: str, limite: int = 10) -> List[Tuple]:
        """Recupera mensagens do usuário"""
        try:
            results = self._execute_with_retry(
                """
                SELECT mensagem, resposta, is_reply, mensagem_original, 
                       reply_to_bot, humor, modo_resposta, nivel_transicao, usuario_privilegiado, timestamp
                FROM mensagens
                WHERE numero = ? AND deletado = 0
                ORDER BY timestamp DESC
                LIMIT ?
                """,
                (str(numero).strip(), limite),
                fetch=True
            )
            
            if results:
                return results[::-1]  # Reverter para ordem cronológica
            return []
        except Exception as e:
            logger.error(f"❌ Erro ao recuperar mensagens: {e}")
            return []

    def recuperar_humor_atual(self, numero: str) -> str:
        """Recupera humor atual"""
        try:
            result = self._execute_with_retry(
                "SELECT humor_atual FROM contexto WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return result[0][0] if result else "normal_ironico"
        except Exception:
            return "normal_ironico"

    def recuperar_modo_resposta(self, numero: str) -> str:
        """Recupera modo de resposta"""
        try:
            result = self._execute_with_retry(
                "SELECT modo_resposta FROM contexto WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return result[0][0] if result else "normal_ironico"
        except Exception:
            return "normal_ironico"

    def recuperar_nivel_transicao(self, numero: str) -> int:
        """Recupera nível de transição"""
        try:
            result = self._execute_with_retry(
                "SELECT nivel_transicao FROM contexto WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return result[0][0] if result else 0
        except Exception:
            return 0

    def recuperar_usuario_privilegiado(self, numero: str) -> bool:
        """Recupera se usuário é privilegiado"""
        try:
            result = self._execute_with_retry(
                "SELECT usuario_privilegiado FROM contexto WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return bool(result[0][0]) if result else False
        except Exception:
            return False

    def recuperar_training_examples(self, limite: int = 100, usado: bool = False) -> List[Dict]:
        """Recupera exemplos de treinamento"""
        try:
            where_clause = "WHERE usado = 0" if not usado else ""
            results = self._execute_with_retry(
                f"""
                SELECT input_text, output_text, humor, modo_resposta, nivel_transicao,
                       usuario_privilegiado, qualidade_score, tipo_interacao
                FROM training_examples
                {where_clause}
                ORDER BY qualidade_score DESC
                LIMIT ?
                """,
                (limite,),
                fetch=True
            )
            
            return [
                {
                    "input": r[0],
                    "output": r[1],
                    "humor": r[2],
                    "modo": r[3],
                    "nivel_transicao": r[4],
                    "usuario_privilegiado": bool(r[5]) if r[5] is not None else False,
                    "score": r[6],
                    "tipo": r[7]
                }
                for r in results
            ]
        except Exception as e:
            logger.error(f"❌ Erro ao recuperar exemplos: {e}")
            return []

    def marcar_examples_como_usados(self, ids: List[int] = None):
        """Marca exemplos como usados"""
        try:
            if ids:
                placeholders = ','.join(['?'] * len(ids))
                query = f"UPDATE training_examples SET usado = 1 WHERE id IN ({placeholders})"
                self._execute_with_retry(query, tuple(ids), commit=True, fetch=False)
            else:
                self._execute_with_retry(
                    "UPDATE training_examples SET usado = 1 WHERE usado = 0",
                    commit=True,
                    fetch=False
                )
        except Exception as e:
            logger.error(f"❌ Erro ao marcar exemplos: {e}")

    # ========================================================================
    # MÉTODO PARA REGISTRAR INTERAÇÃO (PARA TREINAMENTO) - COM usuario_privilegiado
    # ========================================================================
    
    def registrar_interacao(self, numero: str, mensagem: str, resposta: str,
                           humor: str = 'normal_ironico',
                           modo_resposta: str = 'normal_ironico',
                           nivel_transicao: int = 0,
                           usuario_privilegiado: bool = False,  # NOVO PARÂMETRO
                           emocao_detectada: str = None,
                           tipo_conversa: str = 'pv',
                           reply_info_json: str = None,
                           qualidade_score: float = 1.0) -> bool:
        """Registra interação para treinamento - COM usuario_privilegiado"""
        try:
            if isinstance(reply_info_json, dict):
                reply_info_json = json.dumps(reply_info_json, ensure_ascii=False)
            
            self._execute_with_retry(
                """
                INSERT INTO interacoes
                (numero, mensagem, resposta, humor, modo_resposta, nivel_transicao,
                 usuario_privilegiado, emocao_detectada, tipo_conversa, reply_info_json, qualidade_score)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    str(numero).strip(), mensagem[:2000], resposta[:2000], humor, modo_resposta,
                    nivel_transicao, int(usuario_privilegiado), emocao_detectada, 
                    tipo_conversa, reply_info_json, qualidade_score
                ),
                commit=True,
                fetch=False
            )
            logger.debug(f"✅ Interação registrada: {numero} | Nível: {nivel_transicao} | Privilegiado: {usuario_privilegiado}")
            return True
        except Exception as e:
            logger.error(f"❌ Erro ao registrar interação: {e}")
            return False

    # ========================================================================
    # PRIVILÉGIOS
    # ========================================================================
    
    def is_usuario_privilegiado(self, numero: str) -> bool:
        """Verifica se usuário é privilegiado"""
        try:
            result = self._execute_with_retry(
                "SELECT 1 FROM usuarios_privilegiados WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return bool(result)
        except Exception:
            return False

    def pode_usar_reset(self, numero: str) -> bool:
        """Verifica se pode usar reset"""
        try:
            result = self._execute_with_retry(
                "SELECT pode_usar_reset FROM usuarios_privilegiados WHERE numero = ?",
                (str(numero).strip(),),
                fetch=True
            )
            return bool(result and result[0][0])
        except Exception:
            return False

    def registrar_comando(self, numero: str, comando: str, parametros: str = None,
                         sucesso: bool = True, resposta: str = None,
                         tipo_conversa: str = 'pv', grupo_id: str = ''):
        """Registra comando executado"""
        try:
            self._execute_with_retry(
                """
                INSERT INTO comandos_executados
                (numero, comando, parametros, sucesso, resposta, tipo_conversa, grupo_id)
                VALUES (?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    str(numero).strip(), comando, parametros, int(sucesso), resposta, tipo_conversa, grupo_id),
                commit=True,
                fetch=False
            )
        except Exception as e:
            logger.error(f"❌ Erro ao registrar comando: {e}")

    def resetar_contexto_usuario(self, numero: str, tipo: str = "completo") -> Dict:
        """Reseta contexto do usuário"""
        try:
            if not self.pode_usar_reset(numero):
                return {"sucesso": False, "erro": "Sem permissão", "itens_apagados": 0}
            
            itens = 0
            
            # Remove mensagens
            self._execute_with_retry(
                "DELETE FROM mensagens WHERE numero = ?",
                (str(numero).strip(),),
                commit=True,
                fetch=False
            )
            itens += 1
            
            # Remove contexto
            self._execute_with_retry(
                "DELETE FROM contexto WHERE numero = ?",
                (str(numero).strip(),),
                commit=True,
                fetch=False
            )
            itens += 1
            
            logger.info(f"✅ Reset completo para {numero}: {itens} itens")
            return {"sucesso": True, "itens_apagados": itens}
            
        except Exception as e:
            logger.error(f"❌ Erro ao resetar: {e}")
            return {"sucesso": False, "erro": str(e), "itens_apagados": 0}

    # ========================================================================
    # AUXILIARES
    # ========================================================================
    
    def _gerar_contexto_id(self, numero: str, tipo: str = 'auto') -> str:
        """Gera ID único para contexto"""
        if tipo == 'auto':
            num_str = str(numero).lower()
            if "@g.us" in num_str or "grupo_" in num_str or "120363" in num_str:
                tipo = "grupo"
            else:
                tipo = "pv"
        
        data_semana = datetime.now().strftime("%Y-%W")
        salt = f"AKIRA_V21_{data_semana}_ISOLATION"
        raw = f"{str(numero).strip()}|{tipo}|{salt}"
        return hashlib.sha256(raw.encode()).hexdigest()[:32]

    def registrar_tom_usuario(self, numero: str, tom: str, confianca: float = 0.6,
                             mensagem_contexto: str = None) -> bool:
        """Registra tom detectado"""
        try:
            logger.info(f"✅ Tom registrado: {tom} ({confianca:.2f}) para {numero}")
            return True
        except Exception as e:
            logger.error(f"❌ Erro ao registrar tom: {e}")
            return False

    def salvar_aprendizado_detalhado(self, input_text: str, output_text: str,
                                    contexto: Dict, qualidade_score: float = 1.0,
                                    tipo_aprendizado: str = "reply_padrao",
                                    metadata: Dict = None) -> bool:
        """Salva aprendizado detalhado"""
        try:
            contexto_super_claro = {
                'tipo_aprendizado': tipo_aprendizado,
                'metadata': metadata or {},
                'timestamp': time.time()
            }
            
            nivel_transicao = contexto.get('nivel_transicao', 0)
            usuario_privilegiado = contexto.get('usuario_privilegiado', False)
            
            return self.salvar_training_example(
                input_text=input_text,
                output_text=output_text,
                humor=contexto.get("humor_atualizado", "normal_ironico"),
                modo_resposta=contexto.get("modo_resposta", "normal_ironico"),
                nivel_transicao=nivel_transicao,
                usuario_privilegiado=usuario_privilegiado,
                qualidade_score=qualidade_score,
                contexto_super_claro=contexto_super_claro,
                tipo_interacao=tipo_aprendizado
            )
        except Exception as e:
            logger.error(f"❌ Erro ao salvar aprendizado: {e}")
            return False

    def close(self):
        """Fecha conexão"""
        logger.info("✅ Database fechado")

# Singleton
_db_instance = None

def get_database(db_path: str = "akira.db") -> Database:
    global _db_instance
    if _db_instance is None:
        _db_instance = Database(db_path)
    return _db_instance