# x3_generate_scl.py
# -*- coding: utf-8 -*-
import json
import os
import re
import argparse
import sys
import traceback

# --- Importar Generadores Específicos ---
try:
    from generators.generate_scl_db import generate_scl_for_db
    from generators.generate_scl_code_block import generate_scl_for_code_block
    from generators.generate_md_udt import generate_udt_markdown
    from generators.generate_md_tag_table import generate_tag_table_markdown
    # Importar format_variable_name (necesario para el nombre de archivo)
    from generators.generator_utils import format_variable_name
except ImportError as e:
    print(f"Error crítico: No se pudieron importar los módulos de 'generators': {e}")
    print("Asegúrate de que el directorio 'generators' y sus archivos .py existen.")
    sys.exit(1)

# --- Función Principal de Generación (Despachador) ---
def generate_scl_or_markdown(processed_json_filepath, output_directory):
    """
    Genera un archivo SCL o Markdown a partir del JSON procesado,
    llamando a la función generadora apropiada y escribiendo el archivo.
    """
    if not os.path.exists(processed_json_filepath):
        print(f"Error: JSON no encontrado: '{processed_json_filepath}'")
        return

    print(f"Cargando JSON procesado desde: {processed_json_filepath}")
    try:
        with open(processed_json_filepath, "r", encoding="utf-8") as f:
            data = json.load(f)
    except Exception as e:
        print(f"Error al cargar/parsear JSON: {e}"); traceback.print_exc(); return

    block_name = data.get("block_name", "UnknownBlock")
    block_type = data.get("block_type", "Unknown")
    scl_block_name = format_variable_name(block_name) # Nombre seguro para archivo
    output_content = []
    output_extension = ".scl" # Default

    print(f"Generando salida para: {block_type} '{scl_block_name}' (Original: {block_name})")

    # --- Selección del Generador y Extensión ---
    generation_function = None
    if block_type == "PlcUDT":
        print("  -> Modo de generación: UDT Markdown")
        generation_function = generate_udt_markdown
        output_extension = ".md"
    elif block_type == "PlcTagTable":
        print("  -> Modo de generación: Tag Table Markdown")
        generation_function = generate_tag_table_markdown
        output_extension = ".md"
    elif block_type == "GlobalDB":
        print("  -> Modo de generación: DATA_BLOCK SCL")
        generation_function = generate_scl_for_db
        output_extension = ".scl"
    elif block_type in ["FC", "FB", "OB"]:
        print(f"  -> Modo de generación: {block_type} SCL")
        generation_function = generate_scl_for_code_block
        output_extension = ".scl"
    else: # Tipo desconocido
        print(f"Error: Tipo de bloque desconocido '{block_type}'. No se generará archivo.")
        return

    # --- Llamar a la función generadora ---
    if generation_function:
        try:
            output_content = generation_function(data)
        except Exception as gen_e:
            print(f"Error durante la generación de contenido para {block_type} '{scl_block_name}': {gen_e}")
            traceback.print_exc()
            return # No intentar escribir si la generación falla

    # --- Escritura del Archivo de Salida ---
    output_filename_base = f"{scl_block_name}{output_extension}"
    output_filepath = os.path.join(output_directory, output_filename_base)

    print(f"  -> Escribiendo archivo de salida en: {output_filepath}")
    try:
        os.makedirs(output_directory, exist_ok=True)
        with open(output_filepath, "w", encoding="utf-8") as f:
            for line in output_content:
                f.write(line + "\n")
        print(f"Generación de {output_extension.upper()} completada.")
    except Exception as e:
        print(f"Error al escribir el archivo {output_extension.upper()}: {e}")
        traceback.print_exc()

# --- Ejecución ---
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Generate final SCL or Markdown file.")
    parser.add_argument("source_xml_filepath", help="Path to the original source XML file.")
    args = parser.parse_args(); source_xml_file = args.source_xml_filepath
    if not os.path.exists(source_xml_file): print(f"Advertencia (x3): Archivo XML original no encontrado: '{source_xml_file}'.")
    xml_filename_base = os.path.splitext(os.path.basename(source_xml_file))[0]
    base_dir = os.path.dirname(source_xml_file)
    parsing_dir = os.path.join(base_dir, "parsing")
    input_json_file = os.path.join(parsing_dir, f"{xml_filename_base}_processed.json")
    output_dir = base_dir
    print(f"(x3) Generando SCL/MD desde: '{os.path.relpath(input_json_file)}' en directorio: '{os.path.relpath(output_dir)}'")
    if not os.path.exists(input_json_file):
        print(f"Error Fatal (x3): JSON procesado no encontrado: '{input_json_file}'"); sys.exit(1)
    else:
        try: generate_scl_or_markdown(input_json_file, output_dir); sys.exit(0)
        except Exception as e: print(f"Error Crítico (x3): {e}"); traceback.print_exc(); sys.exit(1)