#!/usr/bin/env python3
"""
Script de prueba para el sistema de tokenización distribuida
"""

def test_distributed_tokenization():
    """Prueba el sistema de tokenización distribuida completo"""
    
    print("🧪 PROBANDO SISTEMA DE TOKENIZACIÓN DISTRIBUIDA")
    print("=" * 60)
    
    # Importar dependencias
    try:
        from tl_bracket_parser import TokenizationParser, preview_tokenization, test_tokenization_patterns
        from type_registry import discover_and_register_types, get_registered_base_context
        from main_evaluation import HybridEvaluationEngine
        
        print("✅ Todas las importaciones exitosas")
    except ImportError as e:
        print(f"❌ Error en importaciones: {e}")
        return False
    
    # 1. Probar auto-descubrimiento de tipos
    print("\n1️⃣ PROBANDO AUTO-DESCUBRIMIENTO DE TIPOS")
    print("-" * 40)
    
    try:
        registry_info = discover_and_register_types()
        print(f"✅ Tipos descubiertos: {registry_info['class_count']} clases")
        
        registered_context = get_registered_base_context()
        
        # Verificar clases fundamentales
        fundamental_classes = ['IntBase', 'FourBytes']
        for cls_name in fundamental_classes:
            if cls_name in registered_context:
                print(f"   ✅ {cls_name} registrada")
                
                # Verificar si tiene tokenización
                cls_obj = registered_context[cls_name]
                if hasattr(cls_obj, 'get_tokenization_patterns'):
                    patterns = cls_obj.get_tokenization_patterns()
                    print(f"      🔧 Tiene {len(patterns)} reglas de tokenización")
                    for pattern in patterns:
                        print(f"         📋 Prioridad {pattern['priority']}: {pattern['description']}")
                else:
                    print(f"      ⚠️ Sin reglas de tokenización")
            else:
                print(f"   ❌ {cls_name} NO registrada")
                
    except Exception as e:
        print(f"❌ Error en auto-descubrimiento: {e}")
        return False
    
    # 2. Probar tokenizador universal
    print("\n2️⃣ PROBANDO TOKENIZADOR UNIVERSAL")
    print("-" * 40)
    
    try:
        parser = TokenizationParser(debug=True)
        
        # Casos de prueba
        test_cases = [
            "16#FF",           # IntBase
            "2#1010",          # IntBase  
            "192.168.1.1",    # FourBytes
            "10.x.1.y",       # FourBytes simbólico
            "0xFF",            # Hex con prefijo
            "0b1010",          # Bin con prefijo
            "16#FF + 192.168.1.1",  # Mixto
            "normal + variable",     # Sin tokenización
        ]
        
        print("🧪 Casos de prueba:")
        results = parser.test_patterns(test_cases)
        
        print(f"\n📊 Resultados:")
        print(f"   ✅ Exitosos: {len(results['successful_conversions'])}")
        print(f"   ⚪ Sin cambios: {len(results['failed_conversions'])}")
        
        if results['successful_conversions']:
            print(f"\n🎉 Conversiones exitosas:")
            for expr in results['successful_conversions']:
                result = results['tokenized_results'][expr]
                print(f"   '{expr}' → '{result}'")
        
        # Obtener información de reglas
        tokenization_info = parser.get_tokenization_info()
        print(f"\n📋 {len(tokenization_info['rules'])} reglas activas:")
        for rule in tokenization_info['rules']:
            print(f"   {rule['priority']:2d}: {rule['class']} - {rule['description']}")
            
    except Exception as e:
        print(f"❌ Error en tokenizador: {e}")
        return False
    
    # 3. Probar integración con motor de evaluación
    print("\n3️⃣ PROBANDO INTEGRACIÓN CON MOTOR DE EVALUACIÓN")
    print("-" * 40)
    
    try:
        engine = HybridEvaluationEngine(debug=True)
        
        # Probar expresiones tokenizadas
        test_expressions = [
            "a = 16#FF",
            "b = 192.168.1.1", 
            "c = a + 5",
            "d = b + 256",
            "16#10 + 2#1010",
        ]
        
        print("🧪 Probando expresiones:")
        for expr in test_expressions:
            try:
                result = engine.evaluate_line(expr)
                if result.is_error:
                    print(f"   ❌ '{expr}' → Error: {result.error}")
                else:
                    print(f"   ✅ '{expr}' → {result.result}")
            except Exception as e:
                print(f"   ❌ '{expr}' → Excepción: {e}")
                
    except Exception as e:
        print(f"❌ Error en motor de evaluación: {e}")
        return False
    
    # 4. Prueba de casos específicos reportados por el usuario
    print("\n4️⃣ PROBANDO CASOS ESPECÍFICOS DEL USUARIO")
    print("-" * 40)
    
    try:
        engine = HybridEvaluationEngine()
        
        # El caso específico que reportó el usuario
        test_expression = "m=255.240.0.0 16#ff + 5"
        
        print(f"🎯 Probando: '{test_expression}'")
        
        # Primero ver cómo se tokeniza
        preview = preview_tokenization(test_expression, debug=False)
        print(f"   🔧 Tokenización: '{preview['original']}' → '{preview['tokenized']}'")
        
        # Ahora evaluar
        result = engine.evaluate_line(test_expression)
        if result.is_error:
            print(f"   ❌ Error: {result.error}")
        else:
            print(f"   ✅ Resultado: {result.result}")
            
    except Exception as e:
        print(f"❌ Error en caso específico: {e}")
        return False
    
    print("\n🎉 TODAS LAS PRUEBAS COMPLETADAS")
    return True


if __name__ == "__main__":
    success = test_distributed_tokenization()
    if success:
        print("\n✅ Sistema de tokenización distribuida funcionando correctamente")
    else:
        print("\n❌ Hay problemas en el sistema de tokenización distribuida")