# processors/process_comparison.py
# -*- coding: utf-8 -*-
import sympy
import traceback
from .processor_utils import (
    get_sympy_representation,
    format_variable_name,
)  # No necesita sympy_expr_to_scl aquí
from .symbol_manager import SymbolManager  # Necesita acceso al manager

SCL_SUFFIX = "_sympy_processed"


def process_comparison(
    instruction, network_id, sympy_map, symbol_manager: SymbolManager, data
):
    """
    Genera la expresión SymPy para Comparadores (GT, LT, GE, LE, NE).
    El resultado se propaga por sympy_map['out'].
    """
    instr_uid = instruction["instruction_uid"]
    instr_type_original = instruction.get("type", "")  # GT, LT, GE, LE, NE
    if instr_type_original.endswith(SCL_SUFFIX) or "_error" in instr_type_original:
        return False

    # Mapa de tipos a funciones/clases SymPy Relational
    # Nota: Asegúrate de que los tipos coincidan (ej. si son números o booleanos)
    op_map = {
        "GT": sympy.Gt,  # Greater Than >
        "LT": sympy.Lt,  # Less Than <
        "GE": sympy.Ge,  # Greater or Equal >=
        "LE": sympy.Le,  # Less or Equal <=
        "NE": sympy.Ne,  # Not Equal <> (sympy.Ne maneja esto)
    }
    sympy_relation_func = op_map.get(instr_type_original.upper())
    if not sympy_relation_func:
        instruction["scl"] = (
            f"// ERROR: Tipo de comparación no soportado para SymPy: {instr_type_original}"
        )
        instruction["type"] = instr_type_original + "_error"
        return True

    # Obtener operandos como expresiones SymPy o constantes/strings
    in1_info = instruction["inputs"].get("in1")
    in2_info = instruction["inputs"].get("in2")
    op1_sympy = get_sympy_representation(
        in1_info, network_id, sympy_map, symbol_manager
    )
    op2_sympy = get_sympy_representation(
        in2_info, network_id, sympy_map, symbol_manager
    )

    # Obtener 'pre' (RLO anterior) como expresión SymPy
    pre_input = instruction["inputs"].get(
        "pre"
    )  # Asumiendo que 'pre' es la entrada RLO
    sympy_pre_rlo = (
        get_sympy_representation(pre_input, network_id, sympy_map, symbol_manager)
        if pre_input
        else sympy.true
    )

    # Verificar dependencias
    if op1_sympy is None or op2_sympy is None or sympy_pre_rlo is None:
        # print(f"DEBUG Comparison {instr_uid}: Dependency not ready")
        return False

    # Crear la expresión de comparación SymPy
    try:
        # Convertir constantes string a número si es posible (Sympy puede necesitarlo)
        # Esto es heurístico y puede fallar. Mejor si los tipos son conocidos.
        op1_eval = sympy.sympify(op1_sympy) if isinstance(op1_sympy, str) else op1_sympy
        op2_eval = sympy.sympify(op2_sympy) if isinstance(op2_sympy, str) else op2_sympy
        comparison_expr = sympy_relation_func(op1_eval, op2_eval)

        # IMPORTANTE: Combinar la comparación con la precondición PRE
        # El resultado final es: PRE AND (comparación)
        final_expr = sympy.And(sympy_pre_rlo, comparison_expr)

    except (SyntaxError, TypeError, ValueError) as e:
        print(f"Error creating SymPy comparison for {instr_uid}: {e}")
        instruction["scl"] = f"// ERROR creando expr SymPy Comparison {instr_uid}: {e}"
        instruction["type"] = instr_type_original + "_error"
        return True

    # Guardar resultado en el mapa para 'out' (es una expresión booleana SymPy combinada con PRE)
    map_key_out = (network_id, instr_uid, "out")
    sympy_map[map_key_out] = final_expr

    # Guardar el RLO de entrada ('pre') como ENO en el mapa SymPy
    map_key_eno = (network_id, instr_uid, "eno")
    sympy_map[map_key_eno] = sympy_pre_rlo

    # Marcar como procesado, SCL principal es solo comentario
    instruction["scl"] = (
        f"// SymPy Comparison {instr_type_original}: {final_expr}"  # Comentario opcional
    )
    instruction["type"] = instr_type_original + SCL_SUFFIX
    return True


# --- Processor Information Function ---
def get_processor_info():
    """Devuelve la información para los comparadores (excepto EQ, que debe ser similar)."""
    return [
        {"type_name": "gt", "processor_func": process_comparison, "priority": 2},
        {"type_name": "lt", "processor_func": process_comparison, "priority": 2},
        {"type_name": "ge", "processor_func": process_comparison, "priority": 2},
        {"type_name": "le", "processor_func": process_comparison, "priority": 2},
        {"type_name": "ne", "processor_func": process_comparison, "priority": 2},
        # Asegúrate de tener también un procesador para 'eq' usando sympy.Eq
    ]