# ToUpload/x1_to_json.py
# -*- coding: utf-8 -*-
import json
import argparse
import os
import sys
import traceback
import importlib
from lxml import etree
from collections import defaultdict
import copy

# Importar funciones comunes y namespaces desde el nuevo módulo de utils
try:
    from parsers.parser_utils import ns, get_multilingual_text, parse_interface_members
except ImportError as e:
    print(
        f"Error crítico: No se pudieron importar funciones desde parsers.parser_utils: {e}"
    )
    print(
        "Asegúrate de que el directorio 'parsers' y 'parsers/parser_utils.py' existen y son correctos."
    )
    sys.exit(1)

# --- NUEVAS FUNCIONES DE PARSEO para UDT y Tag Table ---

def parse_udt(udt_element):
    """Parsea un elemento <SW.Types.PlcStruct> (UDT)."""
    print("  -> Detectado: PlcStruct (UDT)")
    block_data = {
        "block_name": "UnknownUDT",
        "block_type": "PlcUDT", # Identificador para x3
        "language": "UDT", # Lenguaje específico
        "interface": {},
        "networks": [], # Los UDTs no tienen redes
        "block_comment": "",
    }

    # Extraer nombre y comentario del UDT (similar a como se hace con bloques)
    attribute_list_node = udt_element.xpath("./AttributeList")
    if attribute_list_node:
        attr_list = attribute_list_node[0]
        name_node = attr_list.xpath("./Name/text()")
        block_data["block_name"] = name_node[0].strip() if name_node else "UnknownUDT"
        # Comentario del UDT
        comment_node_list = udt_element.xpath("./ObjectList/MultilingualText[@CompositionName='Comment']")
        if comment_node_list:
             block_data["block_comment"] = get_multilingual_text(comment_node_list[0])
        else: # Fallback
             comment_attr_node = attr_list.xpath("../ObjectList/MultilingualText[@CompositionName='Comment']") # Buscar desde el padre
             if comment_attr_node :
                 block_data["block_comment"] = get_multilingual_text(comment_attr_node[0])


    # Extraer interfaz (miembros)
    # La interfaz de un UDT suele estar directamente en <Interface><Sections><Section Name="None">
    interface_node_list = udt_element.xpath(
        "./AttributeList/Interface/iface:Sections/iface:Section[@Name='None']", namespaces=ns
    )
    if interface_node_list:
        section_node = interface_node_list[0]
        members_in_section = section_node.xpath("./iface:Member", namespaces=ns)
        if members_in_section:
            # Usar la función existente para parsear miembros
            block_data["interface"]["None"] = parse_interface_members(members_in_section)
        else:
            print(f"Advertencia: Sección 'None' encontrada en UDT '{block_data['block_name']}' pero sin miembros.")
    else:
         # Intentar buscar interfaz directamente si no está en AttributeList (menos común)
         interface_node_direct = udt_element.xpath(
             ".//iface:Interface/iface:Sections/iface:Section[@Name='None']", namespaces=ns
         )
         if interface_node_direct:
              section_node = interface_node_direct[0]
              members_in_section = section_node.xpath("./iface:Member", namespaces=ns)
              if members_in_section:
                   block_data["interface"]["None"] = parse_interface_members(members_in_section)
              else:
                   print(f"Advertencia: Sección 'None' encontrada directamente en UDT '{block_data['block_name']}' pero sin miembros.")
         else:
              print(f"Advertencia: No se encontró la sección 'None' de la interfaz para UDT '{block_data['block_name']}'.")


    if not block_data["interface"]:
         print(f"Advertencia: No se pudo extraer la interfaz del UDT '{block_data['block_name']}'.")

    return block_data

def parse_tag_table(tag_table_element):
    """Parsea un elemento <SW.Tags.PlcTagTable>."""
    print("  -> Detectado: PlcTagTable")
    table_data = {
        "block_name": "UnknownTagTable",
        "block_type": "PlcTagTable", # Identificador para x3
        "language": "TagTable", # Lenguaje específico
        "tags": [],
        "networks": [], # Las Tag Tables no tienen redes
        "block_comment": "", # Las tablas de tags no suelen tener comentario de bloque
    }

    # Extraer nombre de la tabla
    attribute_list_node = tag_table_element.xpath("./AttributeList")
    if attribute_list_node:
        name_node = attribute_list_node[0].xpath("./Name/text()")
        table_data["block_name"] = name_node[0].strip() if name_node else "UnknownTagTable"

    # Extraer tags
    tag_elements = tag_table_element.xpath("./ObjectList/SW.Tags.PlcTag")
    print(f"    - Encontrados {len(tag_elements)} tags.")
    for tag_elem in tag_elements:
        tag_info = {
            "name": "UnknownTag",
            "datatype": "Unknown",
            "address": None,
            "comment": ""
        }
        tag_attr_list = tag_elem.xpath("./AttributeList")
        if tag_attr_list:
            attr_list = tag_attr_list[0]
            name_node = attr_list.xpath("./Name/text()")
            tag_info["name"] = name_node[0].strip() if name_node else "UnknownTag"
            dtype_node = attr_list.xpath("./DataTypeName/text()")
            tag_info["datatype"] = dtype_node[0].strip() if dtype_node else "Unknown"
            addr_node = attr_list.xpath("./LogicalAddress/text()")
            tag_info["address"] = addr_node[0].strip() if addr_node else None

            # Extraer comentario del tag
            comment_node_list = tag_elem.xpath("./ObjectList/MultilingualText[@CompositionName='Comment']")
            if comment_node_list:
                tag_info["comment"] = get_multilingual_text(comment_node_list[0])

        table_data["tags"].append(tag_info)

    return table_data

# --- Cargador Dinámico de Parsers (sin cambios) ---
def load_parsers(parsers_dir="parsers"):
    """
    Escanea el directorio de parsers, importa módulos y construye
    un mapa de lenguaje a función de parseo.
    """
    parser_map = {}
    # Verificar si el directorio existe
    script_dir = os.path.dirname(__file__)
    parsers_dir_path = os.path.join(script_dir, parsers_dir)
    if not os.path.isdir(parsers_dir_path):
        print(f"Error: Directorio de parsers no encontrado: '{parsers_dir_path}'")
        return parser_map # Devuelve mapa vacío

    print(f"Cargando parsers desde: '{parsers_dir_path}'")
    parsers_package = os.path.basename(parsers_dir)

    for filename in os.listdir(parsers_dir_path):
        # Buscar archivos que empiecen con 'parse_' y terminen en '.py'
        # Excluir '__init__.py' y 'parser_utils.py'
        if (
            filename.startswith("parse_")
            and filename.endswith(".py")
            and filename not in ["__init__.py", "parser_utils.py"]
        ):
            module_name_rel = filename[:-3] # Nombre sin .py (e.g., parse_lad_fbd)
            full_module_name = f"{parsers_package}.{module_name_rel}" # e.g., parsers.parse_lad_fbd
            try:
                # Importar el módulo dinámicamente
                module = importlib.import_module(full_module_name)

                # Verificar si el módulo tiene la función get_parser_info
                if hasattr(module, "get_parser_info") and callable(
                    module.get_parser_info
                ):
                    parser_info = module.get_parser_info()
                    # Esperamos un diccionario con 'language' (lista) y 'parser_func'
                    if (
                        isinstance(parser_info, dict)
                        and "language" in parser_info
                        and "parser_func" in parser_info
                    ):
                        languages = parser_info["language"]
                        parser_func = parser_info["parser_func"]

                        if isinstance(languages, list) and callable(parser_func):
                            # Añadir la función al mapa para cada lenguaje que soporta
                            for lang in languages:
                                lang_upper = lang.upper() # Usar mayúsculas como clave
                                if lang_upper in parser_map:
                                    print(
                                        f"  Advertencia: Parser para '{lang_upper}' en {full_module_name} sobrescribe definición anterior."
                                    )
                                parser_map[lang_upper] = parser_func
                                print(
                                    f"  - Cargado parser para '{lang_upper}' desde {module_name_rel}.py"
                                )
                        else:
                            print(
                                f"  Advertencia: Formato inválido en get_parser_info de {full_module_name} (language debe ser lista, parser_func callable)."
                            )
                    else:
                        print(
                            f"  Advertencia: get_parser_info en {full_module_name} no devolvió el diccionario esperado."
                        )
                else:
                    print(
                        f"  Advertencia: Módulo {module_name_rel}.py no tiene la función 'get_parser_info'."
                    )

            except ImportError as e:
                print(f"Error importando {full_module_name}: {e}")
            except Exception as e:
                print(f"Error procesando {full_module_name}: {e}")
                traceback.print_exc()

    print(f"\nTotal de lenguajes con parser cargado: {len(parser_map)}")
    print(f"Lenguajes soportados: {list(parser_map.keys())}")
    return parser_map

# --- Función Principal de Conversión (MODIFICADA) ---
def convert_xml_to_json(xml_filepath, json_filepath, parser_map):
    """Convierte XML a JSON, detectando tipo de bloque (FC/FB/OB/DB/UDT/TagTable)."""
    print(f"Iniciando conversión de '{xml_filepath}' a '{json_filepath}'...")
    if not os.path.exists(xml_filepath):
        print(f"Error Crítico: Archivo XML no encontrado: '{xml_filepath}'")
        return False # Indicar fallo

    try:
        print("Paso 1: Parseando archivo XML...")
        parser = etree.XMLParser(remove_blank_text=True, recover=True) # recover=True puede ayudar
        tree = etree.parse(xml_filepath, parser)
        root = tree.getroot()
        print("Paso 1: Parseo XML completado.")

        result = None # Inicializar resultado

        # --- Detección del tipo de bloque/objeto principal ---
        print("Paso 2: Detectando tipo de objeto principal...")

        # Buscar UDT
        udt_element = root.find(".//SW.Types.PlcStruct", namespaces=root.nsmap)
        if udt_element is not None:
            result = parse_udt(udt_element)

        # Buscar Tag Table si no es UDT
        if result is None:
            tag_table_element = root.find(".//SW.Tags.PlcTagTable", namespaces=root.nsmap)
            if tag_table_element is not None:
                result = parse_tag_table(tag_table_element)

        # Buscar bloque FC/FB/OB/GlobalDB si no es UDT ni Tag Table
        if result is None:
            print("Paso 2: No es UDT ni Tag Table. Buscando SW.Blocks.* ...")
            # Usar local-name() para ignorar namespaces en esta búsqueda inicial
            block_list = root.xpath(
                "//*[local-name()='SW.Blocks.FC' or local-name()='SW.Blocks.FB' or local-name()='SW.Blocks.GlobalDB' or local-name()='SW.Blocks.OB']"
            )
            # (Resto de la lógica de detección de bloques FC/FB/OB/DB como estaba antes...)
            block_type_found = None
            the_block = None

            if block_list:
                the_block = block_list[0]
                block_tag_name = etree.QName(the_block.tag).localname
                if block_tag_name == "SW.Blocks.FC": block_type_found = "FC"
                elif block_tag_name == "SW.Blocks.FB": block_type_found = "FB"
                elif block_tag_name == "SW.Blocks.GlobalDB": block_type_found = "GlobalDB"
                elif block_tag_name == "SW.Blocks.OB": block_type_found = "OB"
                print(f"Paso 2b: Bloque {block_tag_name} (Tipo: {block_type_found}) encontrado (ID={the_block.get('ID')}).")
            else:
                print("Error Crítico: No se encontró el elemento raíz del bloque (<SW.Blocks.FC/FB/GlobalDB/OB>) ni UDT ni Tag Table.")
                return False # Fallo si no se encuentra ningún objeto principal

            # --- Si es FC/FB/OB/DB, continuar con el parseo original ---
            if the_block is not None:
                print("Paso 3: Extrayendo atributos del bloque...")
                # (Extracción de atributos Name, Number, Language como antes...)
                attribute_list_node = the_block.xpath("./AttributeList")
                block_name_val, block_number_val, block_lang_val = "Unknown", None, "Unknown"
                if attribute_list_node:
                    attr_list = attribute_list_node[0]
                    name_node = attr_list.xpath("./Name/text()")
                    block_name_val = name_node[0].strip() if name_node else block_name_val
                    num_node = attr_list.xpath("./Number/text()")
                    try: block_number_val = int(num_node[0]) if num_node else None
                    except (ValueError, TypeError): block_number_val = None
                    lang_node = attr_list.xpath("./ProgrammingLanguage/text()")
                    block_lang_val = (lang_node[0].strip() if lang_node else ("DB" if block_type_found == "GlobalDB" else "Unknown"))
                    print(f"Paso 3: Atributos: Nombre='{block_name_val}', Número={block_number_val}, Lenguaje Bloque='{block_lang_val}'")
                else:
                     print(f"Advertencia: No se encontró AttributeList para el bloque {block_type_found}.")
                     if block_type_found == "GlobalDB": block_lang_val = "DB"

                # (Extracción de comentario como antes...)
                block_comment_val = ""
                comment_node_list = the_block.xpath("./ObjectList/MultilingualText[@CompositionName='Comment']")
                if comment_node_list: block_comment_val = get_multilingual_text(comment_node_list[0])
                else: # Fallback
                    comment_attr_node = the_block.xpath("./AttributeList/Comment") # Buscar desde AttributeList
                    if comment_attr_node : block_comment_val = get_multilingual_text(comment_attr_node[0])

                print(f"Paso 3b: Comentario bloque: '{block_comment_val[:50]}...'")

                # Crear diccionario resultado
                result = {
                    "block_name": block_name_val,
                    "block_number": block_number_val,
                    "language": block_lang_val,
                    "block_type": block_type_found,
                    "block_comment": block_comment_val,
                    "interface": {},
                    "networks": [], # Inicializar networks aquí
                }

                # (Extracción de interfaz como antes...)
                print("Paso 4: Extrayendo la interfaz del bloque...")
                interface_node_list = attribute_list_node[0].xpath("./Interface") if attribute_list_node else []
                if interface_node_list:
                    interface_node = interface_node_list[0]
                    all_sections = interface_node.xpath(".//iface:Section", namespaces=ns)
                    if all_sections:
                        processed_sections = set()
                        for section in all_sections:
                            section_name = section.get("Name")
                            if not section_name or section_name in processed_sections: continue
                            members_in_section = section.xpath("./iface:Member", namespaces=ns)
                            if members_in_section:
                                result["interface"][section_name] = parse_interface_members(members_in_section)
                                processed_sections.add(section_name)
                    else: print("Advertencia: Nodo Interface no contiene secciones <iface:Section>.")
                    if not result["interface"]: print("Advertencia: Interface encontrada pero sin secciones procesables.")
                elif block_type_found == "GlobalDB":
                    static_members = the_block.xpath(".//iface:Section[@Name='Static']/iface:Member", namespaces=ns)
                    if static_members:
                        print("Paso 4: Encontrada sección Static para GlobalDB (sin nodo Interface).")
                        result["interface"]["Static"] = parse_interface_members(static_members)
                    else: print("Advertencia: No se encontró sección 'Static' para GlobalDB.")
                else: print(f"Advertencia: No se encontró <Interface> para bloque {block_type_found}.")
                if not result["interface"]: print("Advertencia: No se pudo extraer información de la interfaz.")

                # (Procesamiento de redes como antes, SOLO si NO es GlobalDB)
                if block_type_found != "GlobalDB":
                    print("Paso 5: Buscando y PROCESANDO redes (CompileUnits)...")
                    networks_processed_count = 0
                    result["networks"] = []
                    object_list_node = the_block.xpath("./ObjectList")
                    if object_list_node:
                        compile_units = object_list_node[0].xpath("./SW.Blocks.CompileUnit")
                        print(f"Paso 5: Se encontraron {len(compile_units)} elementos SW.Blocks.CompileUnit.")

                        # Bucle de parseo de redes (igual que antes)
                        for network_elem in compile_units:
                            networks_processed_count += 1
                            network_id = network_elem.get("ID")
                            if not network_id: continue
                            network_lang = "LAD"
                            net_attr_list = network_elem.xpath("./AttributeList")
                            if net_attr_list:
                                lang_node = net_attr_list[0].xpath("./ProgrammingLanguage/text()")
                                if lang_node: network_lang = lang_node[0].strip()
                            print(f"  - Procesando Red ID={network_id}, Lenguaje Red={network_lang}")
                            parser_func = parser_map.get(network_lang.upper())
                            parsed_network_data = None
                            if parser_func:
                                try:
                                    parsed_network_data = parser_func(network_elem)
                                except Exception as e_parse:
                                    print(f"    ERROR durante el parseo de Red {network_id} ({network_lang}): {e_parse}")
                                    traceback.print_exc()
                                    parsed_network_data = {"id": network_id, "language": network_lang, "logic": [], "error": f"Parser failed: {e_parse}"}
                            else:
                                print(f"    Advertencia: Lenguaje de red '{network_lang}' no soportado.")
                                parsed_network_data = {"id": network_id, "language": network_lang, "logic": [], "error": f"Unsupported language: {network_lang}"}

                            if parsed_network_data:
                                title_element = network_elem.xpath(".//iface:MultilingualText[@CompositionName='Title']",namespaces=ns)
                                parsed_network_data["title"] = (get_multilingual_text(title_element[0]) if title_element else f"Network {network_id}")
                                comment_elem_net = network_elem.xpath("./ObjectList/MultilingualText[@CompositionName='Comment']", namespaces=ns)
                                if not comment_elem_net: comment_elem_net = network_elem.xpath(".//MultilingualText[@CompositionName='Comment']", namespaces=ns) # Fallback
                                parsed_network_data["comment"] = (get_multilingual_text(comment_elem_net[0]) if comment_elem_net else "")
                                result["networks"].append(parsed_network_data)

                        if networks_processed_count == 0: print(f"Advertencia: ObjectList para {block_type_found} sin SW.Blocks.CompileUnit.")
                    else: print(f"Advertencia: No se encontró ObjectList para el bloque {block_type_found}.")
                else: # Es GlobalDB
                    print("Paso 5: Saltando procesamiento de redes para GlobalDB.")


        # --- Escritura del JSON (si se encontró un objeto) ---
        if result:
            print("Paso 6: Escribiendo el resultado en el archivo JSON...")
            # Validaciones finales
            if result.get("block_type") not in ["PlcUDT", "PlcTagTable"] and not result["interface"]:
                 print("ADVERTENCIA FINAL: 'interface' está vacía en el JSON.")
            if result.get("block_type") not in ["PlcUDT", "PlcTagTable", "GlobalDB"] and not result["networks"]:
                 print("ADVERTENCIA FINAL: 'networks' está vacía en el JSON.")

            try:
                with open(json_filepath, "w", encoding="utf-8") as f:
                    json.dump(result, f, indent=4, ensure_ascii=False)
                print("Paso 6: Escritura JSON completada.")
                print(f"Conversión finalizada. JSON guardado en: '{os.path.relpath(json_filepath)}'")
                return True # Indicar éxito

            except IOError as e: print(f"Error Crítico: No se pudo escribir JSON en '{json_filepath}'. Error: {e}"); return False
            except TypeError as e: print(f"Error Crítico: Problema al serializar a JSON. Error: {e}"); return False
        else:
             print("Error Crítico: No se pudo determinar el tipo de objeto principal en el XML.")
             return False


    except etree.XMLSyntaxError as e:
        print(f"Error Crítico: Sintaxis XML inválida en '{xml_filepath}'. Detalles: {e}")
        return False # Indicar fallo
    except Exception as e:
        print(f"Error Crítico: Error inesperado durante la conversión: {e}")
        traceback.print_exc()
        return False # Indicar fallo

# --- Punto de Entrada Principal (__main__) ---
if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Convert Simatic XML (FC/FB/OB/DB/UDT/TagTable) to simplified JSON using dynamic parsers." # Actualizado
    )
    parser.add_argument(
        "xml_filepath",
        help="Path to the input XML file passed from the main script (x0_main.py).",
    )
    args = parser.parse_args()
    xml_input_file = args.xml_filepath

    if not os.path.exists(xml_input_file):
        print(f"Error Crítico (x1): Archivo XML no encontrado: '{xml_input_file}'", file=sys.stderr)
        sys.exit(1)

    # --- Cargar Parsers Dinámicamente ---
    loaded_parsers = load_parsers() # Carga parsers LAD/FBD/STL/SCL
    if not loaded_parsers:
        # Continuar incluso sin parsers de red, ya que podríamos estar parseando UDT/TagTable
        print("Advertencia (x1): No se cargaron parsers de red. Se continuará para UDT/TagTable/DB.")
        #sys.exit(1) # Ya no salimos si no hay parsers de red

    # Derivar nombre de salida JSON
    xml_filename_base = os.path.splitext(os.path.basename(xml_input_file))[0]
    output_dir = os.path.dirname(xml_input_file)
    os.makedirs(output_dir, exist_ok=True)
    json_output_file = os.path.join(output_dir, f"{xml_filename_base}_simplified.json")

    print(f"(x1) Convirtiendo: '{os.path.relpath(xml_input_file)}' -> '{os.path.relpath(json_output_file)}'")

    # Llamar a la función de conversión principal
    success = convert_xml_to_json(xml_input_file, json_output_file, loaded_parsers)

    # Salir con código de error apropiado
    if success:
        sys.exit(0) # Éxito
    else:
        print(f"\nError durante la conversión de '{os.path.relpath(xml_input_file)}'.", file=sys.stderr)
        sys.exit(1) # Fallo