# -*- coding: utf-8 -*-
from .processor_utils import get_scl_representation, format_variable_name,get_target_scl_name


# TODO: Import necessary functions from processor_utils
# Example: from .processor_utils import get_scl_representation, format_variable_name
# Or: import processors.processor_utils as utils

# TODO: Define constants if needed (e.g., SCL_SUFFIX) or import them
SCL_SUFFIX = "_scl"

# --- Function code starts ---
def process_convert(instruction, network_id, scl_map, access_map, data):
    instr_uid = instruction["instruction_uid"]
    instr_type = instruction["type"]
    if instr_type.endswith(SCL_SUFFIX) or "_error" in instr_type:
        return False

    en_input = instruction["inputs"].get("en")
    en_scl = (
        get_scl_representation(en_input, network_id, scl_map, access_map)
        if en_input
        else "TRUE"
    )
    in_info = instruction["inputs"].get("in")
    in_scl = get_scl_representation(in_info, network_id, scl_map, access_map)

    if en_scl is None or in_scl is None:
        return False  # Esperar si dependencias no listas

    target_scl = get_target_scl_name(
        instruction, "out", network_id, default_to_temp=True
    )
    if target_scl is None:
        print(f"Error: Sin destino claro para CONVERT {instr_uid}")
        instruction["scl"] = f"// ERROR: Convert {instr_uid} sin destino"
        instruction["type"] += "_error"
        return True  # Procesado con error

    # Formatear entrada si es variable
    in_scl_formatted = (
        format_variable_name(in_scl)
        if in_info and in_info.get("type") == "variable"
        else in_scl
    )

    # Determinar el tipo de destino (simplificado, necesitaría info del XML original)
    # Asumimos que el tipo está en TemplateValues o inferirlo del nombre/contexto
    target_type = instruction.get("template_values", {}).get(
        "destType", "VARIANT"
    )  # Ejemplo, ajustar según XML real
    conversion_func = f"{target_type}_TO_"  # Necesita el tipo de origen también
    # Esta parte es compleja sin saber los tipos exactos. Usaremos una conversión genérica o MOVE.
    # Para una conversión real, necesitaríamos algo como:
    # conversion_expr = f"CONVERT(IN := {in_scl_formatted}, OUT => {target_scl})" # Sintaxis inventada
    # O usar funciones específicas: INT_TO_REAL, etc.

    # Simplificación: Usar asignación directa (MOVE implícito) o función genérica si existe
    # Asumiremos asignación directa por ahora.
    conversion_expr = in_scl_formatted
    scl_core = f"{target_scl} := {conversion_expr};"

    # Añadir IF EN si es necesario
    scl_final = (
        f"IF {en_scl} THEN\n  {scl_core}\nEND_IF;" if en_scl != "TRUE" else scl_core
    )

    instruction["scl"] = scl_final
    instruction["type"] = instr_type + SCL_SUFFIX
    map_key_out = (network_id, instr_uid, "out")
    scl_map[map_key_out] = target_scl  # El valor de salida es el contenido del destino
    map_key_eno = (network_id, instr_uid, "eno")
    scl_map[map_key_eno] = en_scl  # ENO sigue a EN
    return True

# --- Function code ends ---

# --- Processor Information Function ---
def get_processor_info():
    """Devuelve la información para el procesador Convert."""
    return {'type_name': 'convert', 'processor_func': process_convert, 'priority': 4}