# processors/process_math.py
# -*- coding: utf-8 -*-
import sympy
import traceback
import re

# Usar las nuevas utilidades
from .processor_utils import (
    get_sympy_representation,
    sympy_expr_to_scl,
    get_target_scl_name,
    format_variable_name,
)
from .symbol_manager import SymbolManager

SCL_SUFFIX = "_sympy_processed"


def process_math(
    instruction, network_id, sympy_map, symbol_manager: SymbolManager, data
):
    """
    Genera SCL para operaciones matemáticas (SUB, MUL, DIV, CEIL), simplificando EN.
    """
    instr_uid = instruction["instruction_uid"]
    instr_type_original = instruction.get("type", "")  # SUB, MUL, DIV, CEIL
    if instr_type_original.endswith(SCL_SUFFIX) or "_error" in instr_type_original:
        return False

    # Mapa de tipos a operadores SCL string
    op_map = {"SUB": "-", "MUL": "*", "DIV": "/", "CEIL": "CEIL"}
    scl_operator = op_map.get(instr_type_original.upper())
    if not scl_operator:
        instruction["scl"] = (
            f"// ERROR: Operación matemática no soportada: {instr_type_original}"
        )
        instruction["type"] = instr_type_original + "_error"
        return True

    # Obtener EN (SymPy), IN1, IN2 (SymPy o Constante/String)
    en_input = instruction["inputs"].get("en")
    in1_info = instruction["inputs"].get("in1")
    in2_info = instruction["inputs"].get("in2")
    in_info = instruction["inputs"].get(
        "in"
    )  # Para funciones de un solo operando como CEIL

    sympy_en_expr = (
        get_sympy_representation(en_input, network_id, sympy_map, symbol_manager)
        if en_input
        else sympy.true
    )

    # Para CEIL solo necesitamos un operando
    if instr_type_original.upper() == "CEIL":
        op1_sympy_or_const = get_sympy_representation(
            in_info, network_id, sympy_map, symbol_manager
        )
        op2_sympy_or_const = None
    else:
        op1_sympy_or_const = get_sympy_representation(
            in1_info, network_id, sympy_map, symbol_manager
        )
        op2_sympy_or_const = get_sympy_representation(
            in2_info, network_id, sympy_map, symbol_manager
        )

    # Obtener destino SCL
    target_scl_name = get_target_scl_name(
        instruction, "out", network_id, default_to_temp=True
    )

    # Verificar dependencias
    if sympy_en_expr is None or op1_sympy_or_const is None or target_scl_name is None:
        return False
    if instr_type_original.upper() != "CEIL" and op2_sympy_or_const is None:
        return False

    # Convertir operandos SymPy/Constante a SCL strings
    op1_scl = sympy_expr_to_scl(op1_sympy_or_const, symbol_manager)

    # Generar SCL Core
    if instr_type_original.upper() == "CEIL":
        scl_core = f"{target_scl_name} := CEIL({op1_scl});"
    else:
        op2_scl = sympy_expr_to_scl(op2_sympy_or_const, symbol_manager)

        # Añadir paréntesis si contienen operadores (más seguro)
        # La función sympy_expr_to_scl debería idealmente manejar esto, pero doble chequeo simple:
        op1_scl_formatted = (
            f"({op1_scl})" if re.search(r"[+\-*/ ]", op1_scl) else op1_scl
        )
        op2_scl_formatted = (
            f"({op2_scl})" if re.search(r"[+\-*/ ]", op2_scl) else op2_scl
        )

        scl_core = f"{target_scl_name} := {op1_scl_formatted} {scl_operator} {op2_scl_formatted};"

    # Aplicar Condición EN (Simplificando EN)
    scl_final = ""
    if sympy_en_expr != sympy.true:
        try:
            # simplified_en_expr = sympy.simplify_logic(sympy_en_expr, force=True)
            simplified_en_expr = sympy.logic.boolalg.to_dnf(
                sympy_en_expr, simplify=True
            )
        except Exception as e:
            print(f"Error simplifying EN for {instr_type_original} {instr_uid}: {e}")
            simplified_en_expr = sympy_en_expr  # Fallback
        en_condition_scl = sympy_expr_to_scl(simplified_en_expr, symbol_manager)

        indented_core = "\n".join([f"  {line}" for line in scl_core.splitlines()])
        scl_final = f"IF {en_condition_scl} THEN\n{indented_core}\nEND_IF;"
    else:
        scl_final = scl_core

    # Actualizar instrucción y mapa
    instruction["scl"] = scl_final  # SCL final generado
    instruction["type"] = instr_type_original + SCL_SUFFIX

    # Propagar valor de salida (nombre SCL del destino) y ENO (expresión SymPy)
    map_key_out = (network_id, instr_uid, "out")
    sympy_map[map_key_out] = target_scl_name  # Guardar nombre del destino
    map_key_eno = (network_id, instr_uid, "eno")
    sympy_map[map_key_eno] = sympy_en_expr  # Guardar la expresión SymPy para ENO

    return True


# --- Processor Information Function ---
def get_processor_info():
    """Devuelve info para SUB, MUL, DIV, CEIL."""
    return [
        {"type_name": "sub", "processor_func": process_math, "priority": 4},
        {"type_name": "mul", "processor_func": process_math, "priority": 4},
        {"type_name": "div", "processor_func": process_math, "priority": 4},
        {"type_name": "ceil", "processor_func": process_math, "priority": 4},
    ]