#!/usr/bin/env python3
"""
Prueba del caso específico del usuario: m=255.240.0.0 16#ff + 5
"""

if __name__ == "__main__":
    print("🎯 Probando caso específico del usuario")
    
    try:
        # Debug completo del sistema
        from type_registry import discover_and_register_types, get_registered_base_context
        from tl_bracket_parser import UniversalTokenizer
        
        print("\n🔍 DEBUG COMPLETO DEL SISTEMA:")
        
        # 1. Verificar registro de tipos
        print("\n1. Verificando registro de tipos...")
        registry_info = discover_and_register_types()
        print(f"Clases registradas: {registry_info['class_count']}")
        
        context = get_registered_base_context()
        fundamental_classes = ['IntBase', 'FourBytes']
        
        for cls_name in fundamental_classes:
            if cls_name in context:
                print(f"✅ {cls_name} está registrada")
                cls_obj = 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 i, pattern in enumerate(patterns):
                        print(f"      {i+1}. Prioridad {pattern['priority']}: {pattern['description']}")
                        print(f"         Patrón: {pattern['pattern']}")
                else:
                    print(f"   ❌ Sin reglas de tokenización")
            else:
                print(f"❌ {cls_name} NO está registrada")
        
        # 2. Crear tokenizador y verificar reglas
        print("\n2. Creando tokenizador...")
        tokenizer = UniversalTokenizer()
        print(f"Reglas cargadas en tokenizador: {len(tokenizer.tokenization_rules)}")
        
        if len(tokenizer.tokenization_rules) > 0:
            print("Reglas activas:")
            for i, rule in enumerate(tokenizer.tokenization_rules):
                print(f"   {i+1}. {rule['class_name']} (prioridad {rule['priority']}): {rule['description']}")
        else:
            print("❌ No hay reglas cargadas en el tokenizador")
        
        # 3. Probar tokenización manual
        print("\n3. Probando tokenización manual...")
        tokenizer.debug = True
        
        test_simple = "192.168.1.1"
        print(f"\nProbando: '{test_simple}'")
        result = tokenizer.preprocess_tokens(test_simple)
        print(f"Resultado: '{result}'")
        
        test_hex = "16#ff"
        print(f"\nProbando: '{test_hex}'")
        result = tokenizer.preprocess_tokens(test_hex)
        print(f"Resultado: '{result}'")
        
        # 4. Verificar que las clases estén disponibles en motor
        print("\n4. Verificando motor de evaluación...")
        from main_evaluation import HybridEvaluationEngine
        
        engine = HybridEvaluationEngine()
        engine.debug = True
        
        print(f"Contexto del motor tiene {len(engine.base_context)} entradas")
        
        # Verificar que IntBase y FourBytes estén en el contexto
        for cls_name in ['IntBase', 'FourBytes']:
            if cls_name in engine.base_context:
                print(f"✅ {cls_name} está en contexto del motor")
            else:
                print(f"❌ {cls_name} NO está en contexto del motor")
        
        # 5. Probar evaluación directa
        print("\n5. Probando evaluación directa...")
        
        # Probar evaluación manual sin tokenización
        test_manual = "IntBase('ff', 16)"
        print(f"Probando evaluación manual: {test_manual}")
        try:
            result = engine._eval_in_context(test_manual)
            print(f"✅ Resultado: {result} (tipo: {type(result)})")
        except Exception as e:
            print(f"❌ Error: {e}")
        
        # Probar FourBytes manual
        test_manual2 = "FourBytes('192.168.1.1')"
        print(f"Probando evaluación manual: {test_manual2}")
        try:
            result = engine._eval_in_context(test_manual2)
            print(f"✅ Resultado: {result} (tipo: {type(result)})")
        except Exception as e:
            print(f"❌ Error: {e}")
            
    except Exception as e:
        print(f"Error: {e}")
        import traceback
        traceback.print_exc()