"""
Generador de prompt para adaptación de IO - Este script genera un prompt para ayudar con la
adaptación de IO entre hardware de PLC Siemens TIA Portal y software master.
"""

# Standard library imports
import os
import sys
import tkinter as tk
from tkinter import filedialog, messagebox
import pyperclip  # Para copiar al portapapeles
import shutil  # Para copiar archivos

# Determine script_root and add to sys.path for custom module import
try:
    current_script_path = os.path.abspath(__file__)
    script_root = os.path.dirname(
        os.path.dirname(os.path.dirname(os.path.dirname(current_script_path)))
    )
    if script_root not in sys.path:
        sys.path.append(script_root)

    from backend.script_utils import load_configuration

except ImportError:
    print(
        "Error: No se pudo importar 'load_configuration' desde 'backend.script_utils'."
    )
    sys.exit(1)
except NameError:  # __file__ is not defined
    print(
        "Error: __file__ no está definido. Este script podría no estar ejecutándose en un entorno Python estándar."
    )
    sys.exit(1)


def verify_path(path, is_file=True):
    """Verifica si una ruta existe y es un archivo o directorio según corresponda."""
    if is_file:
        return os.path.isfile(path)
    else:
        return os.path.isdir(path)


def select_obsidian_folder():
    """Permite al usuario seleccionar la carpeta base de Obsidian."""
    root = tk.Tk()
    root.withdraw()  # Ocultar ventana principal

    folder_path = filedialog.askdirectory(
        title="Seleccione la carpeta base de Obsidian", mustexist=True
    )

    return folder_path if folder_path else None


def generate_prompt():
    """
    Genera el prompt para la adaptación de IO y lo copia al portapapeles.
    Verifica la existencia de archivos y directorios.
    """
    # Cargar la configuración para obtener working_directory
    try:
        configs = load_configuration()
        working_directory = configs.get("working_directory")
        if not working_directory:
            print("Error: 'working_directory' no se encontró en la configuración.")
            return False
        if not os.path.isdir(working_directory):
            print(
                f"Error: El directorio de trabajo '{working_directory}' no existe o no es un directorio."
            )
            return False
    except Exception as e:
        print(f"Error al cargar la configuración: {e}")
        return False

    working_directory_abs = os.path.abspath(working_directory)
    print(f"Usando directorio de trabajo: {working_directory_abs}")

    # Variables para las rutas de Obsidian
    obsidian_dir = None
    obsidian_projects_base = None
    obsidian_io_path = None

    # Intentar obtener la carpeta base de Obsidian desde la configuración
    try:
        # Obtener configuración del nivel 2
        group_config = configs.get("level2", {})
        obsidian_dir = group_config.get("ObsideanDir")
        obsidian_projects_base = group_config.get("ObsideanProjectsBase")

        if obsidian_dir and obsidian_projects_base:
            # Path para la carpeta de equivalencias (00 - MASTER/MIXER/IO)
            obsidian_mixer_path = os.path.join(
                obsidian_dir,
                obsidian_projects_base.lstrip("\\"),
                "00 - MASTER",
                "MIXER",
                "IO",
            )

            # Path para la carpeta IO donde se copiará el archivo de salida
            obsidian_io_path = os.path.join(
                obsidian_dir, obsidian_projects_base.lstrip("\\"), "IO"
            )

            # Verificar que la ruta de equivalencias exista
            if os.path.isdir(obsidian_mixer_path):
                print(
                    f"Usando ruta de Obsidian desde configuración: {obsidian_mixer_path}"
                )
            else:
                print(
                    f"Ruta de Obsidian para equivalencias no válida: {obsidian_mixer_path}"
                )
                obsidian_mixer_path = None

            # Crear la carpeta IO si no existe
            if not os.path.isdir(obsidian_io_path):
                try:
                    os.makedirs(obsidian_io_path)
                    print(f"Creada carpeta para salida en Obsidian: {obsidian_io_path}")
                except Exception as e:
                    print(f"No se pudo crear carpeta IO en Obsidian: {e}")
                    obsidian_io_path = None
        else:
            print("Configuración incompleta para las rutas de Obsidian")
    except Exception as e:
        print(f"Error al leer configuración de Obsidian: {e}")

    # Si no se pudo obtener la carpeta desde la configuración, pedirla al usuario
    if not obsidian_mixer_path:
        print(
            "Carpeta de equivalencias en Obsidian no encontrada en configuración o no válida."
        )
        print(
            "Por favor, seleccione la carpeta base de Obsidian para los archivos de equivalencias..."
        )
        obsidian_mixer_path = select_obsidian_folder()

    if not obsidian_mixer_path:
        print("No se seleccionó ninguna carpeta. Saliendo...")
        return False

    print(f"Usando carpeta de equivalencias en Obsidian: {obsidian_mixer_path}")

    # Definir las rutas a los archivos
    master_table_path = os.path.join(working_directory_abs, "Master IO Tags.md")
    hardware_table_path = os.path.join(working_directory_abs, "Hardware.md")
    adaptation_table_path = os.path.join(working_directory_abs, "IO Adapted.md")

    # Rutas a los archivos de datos semánticos
    equivalences_data_path = os.path.join(
        obsidian_mixer_path, "SIDEL - Mixer - Equivalences.md"
    )
    default_io_data_path = os.path.join(obsidian_mixer_path, "Default IO for Analog.md")

    # Verificar que los archivos existan
    files_to_check = [
        {"path": master_table_path, "name": "Master IO Tags.md", "required": True},
        {"path": hardware_table_path, "name": "Hardware.md", "required": True},
        {
            "path": equivalences_data_path,
            "name": "SIDEL - Mixer - Equivalences.md",
            "required": False,
        },
        {
            "path": default_io_data_path,
            "name": "Default IO for Analog.md",
            "required": False,
        },
    ]

    missing_files = []
    for file_info in files_to_check:
        if not verify_path(file_info["path"]):
            if file_info["required"]:
                missing_files.append(f"[REQUERIDO] {file_info['name']}")
            else:
                missing_files.append(f"[OPCIONAL] {file_info['name']}")

    if missing_files:
        print("Los siguientes archivos no se encontraron:")
        for missing_file in missing_files:
            print(f"  - {missing_file}")

        # Si faltan archivos requeridos, preguntar si se quiere continuar
        if any(f.startswith("[REQUERIDO]") for f in missing_files):
            if not messagebox.askyesno(
                "Archivos faltantes",
                "Faltan archivos requeridos. ¿Desea continuar de todos modos?",
            ):
                print("Operación cancelada.")
                return False

    # Generar el texto del prompt
    prompt_text = f"""
Estoy adaptando las entradas y salidas entre un hardware de PLC Siemens Tia Portal y un software master. Para lograr identificar que tags del software master se deben asignar a cada IO del hardware del PLC. Se debe asignar a cada IO del harware un Tag del software master. 
Para que me ayudes con este proceso de busqueda he creado las tablas:

$Master_table: que contiene los tags del software master con las descripciones. Esta tabla se divide en 4 subtablas. La "Inputs PLCTags" son los inputs mas utilizados, luego estan los "InputsMaster PLCTags" que son inputs menos utilizados. Lo mismo sucede con "Outputs PLCTags" que son los mas utilizados y "OutputsMaster PLCTags" son los outputs menos utilizados. 

$Hardware_table: que contiene todo el IO del hardware del PLC. Esta dibidido en diferentes dispositivos ya que algunos componentes se acceden mediante interfaces de comunicaciones como profibus. Pero desde el punto de vista del PLC son inputs o outputs definidos como PEW que significa: P:periferia, W:word , se sigue la nomenclatura alemana de siemens, A:output, E:input. 

$Adaptation_table: es la tabla que deseo que crees con los IO adaptados. Seria la $Hardware_table con los tags de la $Master_table. Quisiera que se agrege una columna con el nivel de certeza y en caso que el nivel no sea el maximo quisiera que agregues 3 posibles opciones como tag1,tag2,tag3 en una columna nueva.

$Equivalences_data tiene información de ciertas equivalencias que pueden ser útiles para las búsquedas. 
$DefaultIO_data tiene conexiones estandard en los casos mas comunes.

Para acceder a los archivos para leer o escribir puedes usar el MCP filesystem. 

# Definiciones de rutas
$Working_Directory = "{working_directory_abs}"
$Obsidean_Base_Folder = "{obsidian_mixer_path}"

# Archivos de entrada
$Master_table = $Working_Directory + "/Master IO Tags.md"
$Hardware_table = $Working_Directory + "/Hardware.md"

# Archivo de salida
$Adaptation_table = $Working_Directory + "/IO Adapted.md"

# Datos semánticos de apoyo
$Equivalences_data = "{equivalences_data_path}"
$DefaultIO_data = "{default_io_data_path}"

# CONTEXTO DEL PROYECTO
Estoy realizando un upgrade de software para equipos SIDEL que migran de un sistema antiguo a uno nuevo. Estos equipos de mezclado de bebidas (mixers) tienen hardware de PLC Siemens que debe ser adaptado al software master moderno. La correcta asignación de entradas/salidas es fundamental para que el sistema funcione adecuadamente.

# OBJETIVO
Crear una tabla de adaptación que asigne correctamente cada entrada/salida (I/O) del hardware de PLC Siemens TIA Portal a los tags correspondientes del software master moderno. Este mapeo permitirá la comunicación efectiva entre el hardware existente y el nuevo software de control.

# TECNOLOGÍA Y NOMENCLATURA
- Sistema de control: Siemens PLC con TIA Portal
- Nomenclatura Siemens (alemana):
  * E: Entrada (Input) - Ejemplo: I0.1, EW100
  * A: Salida (Output) - Ejemplo: Q0.1, AW100
  * P: Periferia
  * W: Word (16 bits)
  * D: Double Word (32 bits)
- PEW: Entrada de Periferia Word (Peripheral Input Word)
- PAW: Salida de Periferia Word (Peripheral Output Word)

# DESCRIPCIÓN DE LOS ARCHIVOS

## Hardware_table ($Hardware_table)
- FUNCIÓN: Contiene la configuración completa del hardware del PLC y el detalle de todas las señales de I/O físicas.
- ESTRUCTURA: 
  * Primera sección: Tabla de configuración del PLC con red, direcciones y dispositivos
  * Segunda sección: Tabla de I/O con dirección (ej. I0.1, PEW100), descripción en italiano/inglés y sensor asociado
- INFORMACIÓN CLAVE: Direcciones de hardware, descripciones físicas y conexiones de sensores/actuadores

## Master_table ($Master_table)
- FUNCIÓN: Define los tags estandarizados en el software master moderno que deben mapearse a las I/O físicas.
- ESTRUCTURA: Dividido en 4 secciones:
  * "Inputs PLCTags": Entradas más utilizadas
  * "InputsMaster PLCTags": Entradas secundarias
  * "Outputs PLCTags": Salidas más utilizadas
  * "OutputsMaster PLCTags": Salidas secundarias
- INFORMACIÓN CLAVE: Tags estandarizados, tipos de datos y descripciones en inglés

## Equivalences_data ($Equivalences_data)
- FUNCIÓN: Proporciona equivalencias semánticas entre terminologías antiguas/nuevas y abreviaturas.
- ESTRUCTURA: Listado de equivalencias como "301 : WATER PUMP = P1"
- INFORMACIÓN CLAVE: Traducciones entre nomenclaturas, equivalencias entre códigos y nombres descriptivos

## DefaultIO_data ($DefaultIO_data)
- FUNCIÓN: Contiene configuraciones predeterminadas para señales analógicas específicas.
- ESTRUCTURA: Tabla con tags, tipos de datos y direcciones de memoria para señales analógicas estándar
- INFORMACIÓN CLAVE: Mapeos predefinidos para señales analógicas comunes, especialmente para comunicación Profibus

## Adaptation_table (a crear en $Adaptation_table)
- FUNCIÓN: Tabla final que mapea cada I/O del hardware a su correspondiente tag del master.
- ESTRUCTURA: Formato requerido:
  | IO | Master Tag | PLC Description | Master Description | Certeza | Alternative |
- INFORMACIÓN CLAVE: Resultado del proceso de adaptación con nivel de confianza y alternativas

# PROCESO DE ADAPTACIÓN
Lee ambos archivos ($Hardware_table y $Master_table) y crea una tabla de adaptación que asigne a cada IO del hardware un Tag del software master.

El proceso de asignación debe:
1. Comparar semánticamente descripciones entre ambas tablas, teniendo en cuenta el idioma (italiano/inglés)
2. Verificar compatibilidad de tipo (input/output) y tamaño de datos
3. Utilizar las equivalencias en $Equivalences_data para mejorar la coincidencia semántica
4. Verificar configuraciones estándar en $DefaultIO_data para señales analógicas
5. Priorizar los tags de las tablas principales ("Inputs PLCTags"/"Outputs PLCTags") sobre las secundarias

# FORMATO DE SALIDA
Crea la tabla con esta estructura exacta:
| IO | Master Tag | PLC Description | Master Description | Certeza | Alternative |

# NIVELES DE CERTEZA
Asigna niveles de certeza según estos criterios:
- Alto (90%+): Coincidencia evidente en nombre y descripción
- Medio (70-90%): Similitud semántica notable pero no exacta
- Bajo (<70%): Similitud limitada, requiere revisión manual

Para entradas con nivel de certeza medio o bajo, añade hasta 3 tags alternativos en la columna "Alternative" separados por comas.

# EXCEPCIONES
Al final del documento, crea una sección titulada "## Excepciones y Problemas" con una tabla que liste las IO sin asignación clara y el problema detectado.
"""

    # Copiar el texto al portapapeles
    try:
        pyperclip.copy(prompt_text)
        print("¡Prompt generado y copiado al portapapeles con éxito!")

        # Guardar el prompt en un archivo para referencia
        prompt_file_path = os.path.join(
            working_directory_abs, "IO_Adaptation_Prompt.txt"
        )
        with open(prompt_file_path, "w", encoding="utf-8") as f:
            f.write(prompt_text)
        print(f"Prompt guardado en: {prompt_file_path}")

        # También copiar el archivo IO Adapted.md a la carpeta de Obsidian cuando se genere
        if obsidian_io_path:
            # Crear un mensaje para informar al usuario
            copy_message = ""

            # Explicar que la copia se realizará cuando se genere el archivo
            copy_message = (
                f"Se copiará automáticamente el archivo 'IO Adapted.md' a:\n"
                f"{obsidian_io_path}\n\n"
                f"cuando sea generado por la herramienta."
            )

            # Añadir la información sobre la copia al mensaje de éxito
            success_message = (
                f"Prompt generado y copiado al portapapeles.\n\n"
                f"También se ha guardado en:\n{prompt_file_path}\n\n"
                f"{copy_message}"
            )

            messagebox.showinfo("Éxito", success_message)
        else:
            # Mostrar mensaje de éxito sin la parte de copia
            messagebox.showinfo(
                "Éxito",
                f"Prompt generado y copiado al portapapeles.\n\n"
                f"También se ha guardado en:\n{prompt_file_path}",
            )

        return True
    except Exception as e:
        print(f"Error al copiar al portapapeles: {e}")
        messagebox.showerror(
            "Error",
            f"Error al copiar al portapapeles: {e}\n\n"
            f"Por favor, instale pyperclip con 'pip install pyperclip'",
        )
        return False


# Agregar una función para copiar el archivo adaptado a Obsidian
def copy_adapted_file_to_obsidian():
    """Copia el archivo IO Adapted.md al directorio de IO en Obsidian si existe"""
    try:
        configs = load_configuration()
        working_directory = configs.get("working_directory")
        if not working_directory:
            return False

        # Verificar si el archivo existe en el directorio de trabajo
        source_file = os.path.join(working_directory, "IO Adapted.md")
        if not os.path.isfile(source_file):
            print(f"Archivo '{source_file}' no encontrado.")
            return False

        # Obtener la ruta de destino en Obsidian
        group_config = configs.get("level2", {})
        obsidian_dir = group_config.get("ObsideanDir")
        obsidian_projects_base = group_config.get("ObsideanProjectsBase")

        if not obsidian_dir or not obsidian_projects_base:
            print("Configuración de Obsidian incompleta.")
            return False

        # Construir la ruta de destino
        obsidian_io_path = os.path.join(
            obsidian_dir, obsidian_projects_base.lstrip("\\"), "IO"
        )

        # Crear la carpeta si no existe
        if not os.path.exists(obsidian_io_path):
            os.makedirs(obsidian_io_path)

        # Definir el destino
        dest_file = os.path.join(obsidian_io_path, "IO Adapted.md")

        # Copiar el archivo
        shutil.copy2(source_file, dest_file)
        print(f"Archivo copiado exitosamente a: {dest_file}")

        return True
    except Exception as e:
        print(f"Error al copiar archivo a Obsidian: {e}")
        return False


if __name__ == "__main__":
    print("Generador de prompt para adaptación de IO")
    print("=========================================")
    generate_prompt()
