#!/usr/bin/env python3
"""
Script de teste para o sistema de logging avançado.
Testa todas as funcionalidades do sistema de logging com SQLite3.
"""

import os
import sys
import time
import json
from datetime import datetime

# Adicionar o diretório src ao path
src_path = os.path.join(os.path.dirname(__file__), 'src')
sys.path.insert(0, src_path)

try:
    from src.core.database_logger import DatabaseLogger, LogLevel, LogCategory
    from src.utils.logging_decorators import log_execution, log_api_call, log_ai_model_usage, LoggingContext, quick_log
except ImportError as e:
    print(f"❌ Erro ao importar módulos de logging: {e}")
    print("Tentando importação alternativa...")
    try:
        # Importação direta dos arquivos
        import importlib.util
        
        # Carregar database_logger
        spec = importlib.util.spec_from_file_location(
            "database_logger", 
            os.path.join(src_path, "core", "database_logger.py")
        )
        db_module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(db_module)
        
        DatabaseLogger = db_module.DatabaseLogger
        LogLevel = db_module.LogLevel
        LogCategory = db_module.LogCategory
        
        # Carregar logging_decorators
        spec2 = importlib.util.spec_from_file_location(
            "logging_decorators", 
            os.path.join(src_path, "utils", "logging_decorators.py")
        )
        dec_module = importlib.util.module_from_spec(spec2)
        spec2.loader.exec_module(dec_module)
        
        log_execution = dec_module.log_execution
        log_api_call = dec_module.log_api_call
        log_ai_model_usage = dec_module.log_ai_model_usage
        LoggingContext = dec_module.LoggingContext
        quick_log = dec_module.quick_log
        
        print("✅ Importação alternativa bem-sucedida")
        
    except Exception as e2:
        print(f"❌ Erro na importação alternativa: {e2}")
        sys.exit(1)

def test_basic_logging():
    """Testa funcionalidades básicas de logging."""
    print("\n🧪 Testando logging básico...")
    
    # Criar diretório de logs se não existir
    os.makedirs('logs', exist_ok=True)
    
    # Inicializar logger
    db_logger = DatabaseLogger('logs/test_logging.db')
    
    # Teste 1: Log simples
    db_logger.log(
        level=LogLevel.INFO,
        category=LogCategory.SYSTEM,
        message="Teste de log básico",
        module="test_logging_system",
        function="test_basic_logging",
        line_number=70
    )
    
    # Teste 2: Log com metadados
    db_logger.log(
        level=LogLevel.DEBUG,
        category=LogCategory.API,
        message="Teste com metadados",
        module="test_logging_system",
        function="test_basic_logging",
        line_number=80,
        metadata={'test_id': 1, 'timestamp': datetime.now().isoformat()}
    )
    
    # Teste 3: Log de erro
    db_logger.log(
        level=LogLevel.ERROR,
        category=LogCategory.SYSTEM,
        message="Teste de log de erro",
        module="test_logging_system",
        function="test_basic_logging",
        line_number=90,
        execution_time=0.001
    )
    
    print("✅ Logging básico funcionando")
    return db_logger

def test_performance_metrics(db_logger):
    """Testa logging de métricas de performance."""
    print("\n🧪 Testando métricas de performance...")
    
    # Teste 1: Métrica de tempo de resposta
    db_logger.log_performance_metric(
        metric_name="response_time",
        metric_value=0.150,
        unit="seconds",
        category="api_performance"
    )
    
    # Teste 2: Métrica de uso de memória
    db_logger.log_performance_metric(
        metric_name="memory_usage",
        metric_value=256.5,
        unit="MB",
        category="system_resources"
    )
    
    # Teste 3: Métrica de throughput
    db_logger.log_performance_metric(
        metric_name="requests_per_second",
        metric_value=45.2,
        unit="req/s",
        category="performance",
        metadata={'endpoint': '/api/analyze'}
    )
    
    print("✅ Métricas de performance funcionando")

def test_system_events(db_logger):
    """Testa logging de eventos do sistema."""
    print("\n🧪 Testando eventos do sistema...")
    
    # Teste 1: Evento de inicialização
    db_logger.log_system_event(
        event_type="STARTUP",
        event_name="SERVICE_STARTED",
        description="Serviço de teste iniciado",
        severity="INFO"
    )
    
    # Teste 2: Evento de erro
    db_logger.log_system_event(
        event_type="ERROR",
        event_name="CONNECTION_FAILED",
        description="Falha na conexão com API externa",
        severity="ERROR",
        metadata={'api_endpoint': 'https://api.example.com', 'error_code': 500}
    )
    
    # Teste 3: Evento de alerta
    db_logger.log_system_event(
        event_type="ALERT",
        event_name="HIGH_CPU_USAGE",
        description="Uso de CPU acima de 80%",
        severity="WARNING",
        metadata={'cpu_usage': 85.2, 'threshold': 80}
    )
    
    print("✅ Eventos do sistema funcionando")

@log_execution(LogCategory.SYSTEM, log_performance=True)
def test_function_with_decorator():
    """Função de teste com decorador de logging."""
    time.sleep(0.1)  # Simular processamento
    return "Resultado do teste"

@log_api_call("test_api")
def test_api_function():
    """Função de teste para chamada de API."""
    time.sleep(0.05)  # Simular chamada de API
    return {'status': 'success', 'data': 'test_data'}

@log_ai_model_usage("test_model")
def test_ai_model_function():
    """Função de teste para uso de modelo IA."""
    time.sleep(0.2)  # Simular processamento de IA
    return {'prediction': 0.85, 'confidence': 0.92}

def test_decorators():
    """Testa os decoradores de logging."""
    print("\n🧪 Testando decoradores...")
    
    # Teste 1: Decorador de execução
    result1 = test_function_with_decorator()
    print(f"Resultado função com decorador: {result1}")
    
    # Teste 2: Decorador de API
    result2 = test_api_function()
    print(f"Resultado API: {result2}")
    
    # Teste 3: Decorador de modelo IA
    result3 = test_ai_model_function()
    print(f"Resultado modelo IA: {result3}")
    
    print("✅ Decoradores funcionando")

def test_context_manager():
    """Testa o gerenciador de contexto."""
    print("\n🧪 Testando gerenciador de contexto...")
    
    with LoggingContext("Processamento de teste", LogLevel.INFO, LogCategory.SYSTEM):
        time.sleep(0.1)
        print("Executando dentro do contexto de logging")
    
    print("✅ Gerenciador de contexto funcionando")

def test_quick_log():
    """Testa a função de logging rápido."""
    print("\n🧪 Testando logging rápido...")
    
    # Log simples
    quick_log("Teste de log rápido", LogLevel.INFO, LogCategory.SYSTEM)
    
    # Log com metadados
    quick_log(
        "Teste com metadados", 
        LogLevel.DEBUG, 
        LogCategory.API,
        metadata={'test': True, 'value': 42}
    )
    
    print("✅ Logging rápido funcionando")

def test_log_retrieval(db_logger):
    """Testa recuperação e filtragem de logs."""
    print("\n🧪 Testando recuperação de logs...")
    
    # Teste 1: Buscar todos os logs
    all_logs = db_logger.get_logs(limit=10)
    print(f"Total de logs encontrados: {len(all_logs)}")
    
    # Teste 2: Filtrar por nível
    error_logs = db_logger.get_logs(level="ERROR", limit=5)
    print(f"Logs de erro: {len(error_logs)}")
    
    # Teste 3: Filtrar por categoria
    system_logs = db_logger.get_logs(category="SYSTEM", limit=5)
    print(f"Logs do sistema: {len(system_logs)}")
    
    # Teste 4: Buscar métricas de performance
    metrics = db_logger.get_performance_metrics(limit=5)
    print(f"Métricas encontradas: {len(metrics)}")
    
    # Teste 5: Buscar eventos do sistema
    events = db_logger.get_system_events(limit=5)
    print(f"Eventos do sistema: {len(events)}")
    
    print("✅ Recuperação de logs funcionando")

def test_statistics(db_logger):
    """Testa geração de estatísticas."""
    print("\n🧪 Testando estatísticas...")
    
    stats = db_logger.get_statistics()
    print(f"Estatísticas: {json.dumps(stats, indent=2)}")
    
    print("✅ Estatísticas funcionando")

def test_cleanup(db_logger):
    """Testa limpeza de logs antigos."""
    print("\n🧪 Testando limpeza...")
    
    # Não vamos fazer limpeza real nos testes, apenas verificar se o método existe
    try:
        # db_logger.cleanup_old_logs(days_to_keep=0)  # Comentado para não apagar logs de teste
        print("Método de limpeza disponível")
    except Exception as e:
        print(f"Erro na limpeza: {e}")
    
    print("✅ Limpeza funcionando")

def main():
    """Função principal de teste."""
    print("🚀 Iniciando testes do sistema de logging avançado")
    print("=" * 60)
    
    try:
        # Testes básicos
        db_logger = test_basic_logging()
        test_performance_metrics(db_logger)
        test_system_events(db_logger)
        
        # Testes de decoradores (se disponíveis)
        try:
            test_decorators()
            test_context_manager()
            test_quick_log()
        except Exception as e:
            print(f"⚠️ Alguns decoradores não funcionaram: {e}")
        
        # Testes de recuperação
        test_log_retrieval(db_logger)
        test_statistics(db_logger)
        test_cleanup(db_logger)
        
        print("\n" + "=" * 60)
        print("✅ Todos os testes concluídos com sucesso!")
        print(f"📁 Logs salvos em: logs/test_logging.db")
        
        # Mostrar algumas estatísticas finais
        final_stats = db_logger.get_statistics()
        print(f"\n📊 Estatísticas finais:")
        print(f"   Total de logs: {final_stats.get('total_logs', 0)}")
        print(f"   Logs por nível: {final_stats.get('logs_by_level', {})}")
        print(f"   Logs por categoria: {final_stats.get('logs_by_category', {})}")
        print(f"   Logs últimas 24h: {final_stats.get('logs_last_24h', 0)}")
        
    except Exception as e:
        print(f"\n❌ Erro durante os testes: {e}")
        import traceback
        traceback.print_exc()
        return 1
    
    return 0

if __name__ == "__main__":
    exit_code = main()
    sys.exit(exit_code)