# processors/process_eq.py
# -*- coding: utf-8 -*-
import sympy
import traceback
# Usar las nuevas utilidades de SymPy
from .processor_utils import get_sympy_representation, format_variable_name
from .symbol_manager import SymbolManager

SCL_SUFFIX = "_sympy_processed" # Nuevo sufijo

def process_eq(instruction, network_id, sympy_map, symbol_manager: SymbolManager, data):
    """
    Genera la expresión SymPy para el comparador de igualdad (EQ).
    El resultado se propaga por sympy_map['out'].
    """
    instr_uid = instruction["instruction_uid"]
    instr_type_original = instruction.get("type", "Eq")
    if instr_type_original.endswith(SCL_SUFFIX) or "_error" in instr_type_original:
        return False

    # 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") # Asumir 'pre' como entrada RLO estándar
    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 EQ {instr_uid}: Dependency not ready")
        return False

    # Crear la expresión de igualdad SymPy
    try:
        # sympify puede ser necesario si los operandos son strings de constantes
        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.Eq(op1_eval, op2_eval) # Eq para igualdad
    except (SyntaxError, TypeError, ValueError) as e:
        print(f"Error creating SymPy equality for {instr_uid}: {e}")
        instruction["scl"] = f"// ERROR creando expr SymPy EQ {instr_uid}: {e}"
        instruction["type"] = instr_type_original + "_error"
        return True

    # Guardar resultado (Expresión SymPy booleana) en el mapa para 'out'
    map_key_out = (network_id, instr_uid, "out")
    sympy_map[map_key_out] = comparison_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 EQ: {comparison_expr}" # Comentario opcional
    instruction["type"] = instr_type_original + SCL_SUFFIX
    return True

# --- Processor Information Function ---
def get_processor_info():
    """Devuelve la información para el comparador de igualdad (EQ)."""
    return {'type_name': 'eq', 'processor_func': process_eq, 'priority': 2}