import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
from ...Library.Python import funciones_comunes as fc
import x1_importar_to_master
import x2_master_export2translate
import x3_llm_auto_translate
import x4_integrate_translates_to_master
import x5_complete_empty_cells_master
import x6_update_from_master
import sys
import threading
import configparser  # Para manejar el archivo de configuración
import os  # Para verificar si el archivo existe

# Crear la ventana principal
ventana = tk.Tk()
ventana.title("Ayuda para traducir textos de TIA Portal y Allen Bradley")
ventana.geometry("800x600")  # Ajustamos el tamaño de la ventana

# Diccionario para tipo_PLC
tipo_PLC_dict = {'Siemens': 'siemens', 'AllenBradley': 'allenbradley'}

# Variables para almacenar las selecciones del usuario
tipo_PLC_var = tk.StringVar()
codigo_columna_maestra_var = tk.StringVar()
idioma_var = tk.StringVar()
idioma_var2 = tk.StringVar()

# Crear listas de idiomas con sus códigos
idiomas_lista = [(nombre, codigo) for _, (nombre, codigo) in fc.IDIOMAS.items()]

# Ruta del archivo de configuración
config_file = 'config.ini'

# Función para cargar las opciones guardadas
def cargar_configuracion():
    config = configparser.ConfigParser()
    if os.path.exists(config_file):
        config.read(config_file)
        # Cargar tipo_PLC
        tipo_PLC_var.set(config.get('Seleccion', 'tipo_PLC', fallback='Siemens'))
        # Cargar codigo_columna_maestra
        codigo_columna_maestra_var.set(config.get('Seleccion', 'codigo_columna_maestra', fallback=idiomas_lista[0][0]))
        # Cargar idioma_var
        idioma_var.set(config.get('Seleccion', 'idioma_var', fallback=idiomas_lista[4][0]))
        # Cargar idioma_var2
        idioma_var2.set(config.get('Seleccion', 'idioma_var2', fallback=idiomas_lista[1][0]))
    else:
        # Valores por defecto si no existe el archivo
        tipo_PLC_var.set('Siemens')
        codigo_columna_maestra_var.set(idiomas_lista[0][0])
        idioma_var.set(idiomas_lista[4][0])
        idioma_var2.set(idiomas_lista[1][0])

# Función para guardar las opciones seleccionadas
def guardar_configuracion():
    config = configparser.ConfigParser()
    config['Seleccion'] = {
        'tipo_PLC': tipo_PLC_var.get(),
        'codigo_columna_maestra': codigo_columna_maestra_var.get(),
        'idioma_var': idioma_var.get(),
        'idioma_var2': idioma_var2.get()
    }
    # Guardar el contenido del cuadro de texto
    config['TextContent'] = {
        'output_text': output_text.get("1.0", tk.END)
    }
    with open(config_file, 'w') as configfile:
        config.write(configfile)

# Crear un Frame para la grilla de comboboxes
frame_combos = tk.Frame(ventana)
frame_combos.pack(pady=10)

# Crear los labels y comboboxes
label_tipo_PLC = tk.Label(frame_combos, text="Selecciona el tipo de PLC:")
combo_tipo_PLC = ttk.Combobox(frame_combos, textvariable=tipo_PLC_var, state="readonly")
combo_tipo_PLC["values"] = list(tipo_PLC_dict.keys())

label_codigo_maestra = tk.Label(frame_combos, text="Idioma Columna Maestra:")
combo_codigo_maestra = ttk.Combobox(frame_combos, textvariable=codigo_columna_maestra_var, state="readonly")
combo_codigo_maestra["values"] = [nombre for nombre, _ in idiomas_lista]

label1 = tk.Label(frame_combos, text="Idioma de Traducción:")
combo = ttk.Combobox(frame_combos, textvariable=idioma_var, state="readonly")
combo["values"] = [nombre for nombre, _ in idiomas_lista]

label2 = tk.Label(frame_combos, text="Selecciona segundo idioma:")
combo2 = ttk.Combobox(frame_combos, textvariable=idioma_var2, state="readonly")
combo2["values"] = [nombre for nombre, _ in idiomas_lista]

# Organizar los labels y comboboxes en una grilla 2x2
label_tipo_PLC.grid(row=0, column=0, padx=5, pady=5, sticky='e')
combo_tipo_PLC.grid(row=0, column=1, padx=5, pady=5, sticky='w')

label_codigo_maestra.grid(row=1, column=0, padx=5, pady=5, sticky='e')
combo_codigo_maestra.grid(row=1, column=1, padx=5, pady=5, sticky='w')

label1.grid(row=0, column=2, padx=5, pady=5, sticky='e')
combo.grid(row=0, column=3, padx=5, pady=5, sticky='w')

label2.grid(row=1, column=2, padx=5, pady=5, sticky='e')
combo2.grid(row=1, column=3, padx=5, pady=5, sticky='w')

# Función para actualizar combo_codigo_maestra según la selección en combo_tipo_PLC
def actualizar_codigo_maestra(event):
    plc_seleccionado = tipo_PLC_var.get()
    if plc_seleccionado == 'Siemens':
        # Buscar el índice de 'Italian' en idiomas_lista
        indice_italiano = next((i for i, (nombre, _) in enumerate(idiomas_lista) if nombre == 'Italian'), None)
        if indice_italiano is not None:
            combo_codigo_maestra.current(indice_italiano)
    elif plc_seleccionado == 'AllenBradley':
        # Buscar el índice de 'English_US' en idiomas_lista
        indice_ingles = next((i for i, (nombre, _) in enumerate(idiomas_lista) if nombre == 'English_US'), None)
        if indice_ingles is not None:
            combo_codigo_maestra.current(indice_ingles)
    guardar_configuracion()  # Guardar la configuración cuando se cambia el tipo de PLC

# Vincular la función al evento de cambio de selección en combo_tipo_PLC
combo_tipo_PLC.bind('<<ComboboxSelected>>', actualizar_codigo_maestra)

# Vincular eventos de cambio en los comboboxes para guardar la configuración
def on_combobox_changed(event):
    guardar_configuracion()

combo_codigo_maestra.bind('<<ComboboxSelected>>', on_combobox_changed)
combo.bind('<<ComboboxSelected>>', on_combobox_changed)
combo2.bind('<<ComboboxSelected>>', on_combobox_changed)

# Clase para redirigir la salida estándar a la caja de texto
class RedirectText(object):
    def __init__(self, text_widget):
        self.output = text_widget

    def write(self, string):
        self.output.insert(tk.END, string)
        self.output.see(tk.END)  # Desplaza hacia el final

    def flush(self):
        pass  # No se requiere implementación para flush

# Función para obtener el código del idioma seleccionado a partir del nombre
def obtener_codigo_idioma_por_nombre(nombre_idioma):
    for nombre, codigo in idiomas_lista:
        if nombre == nombre_idioma:
            return codigo
    return None

# Función para ejecutar las funciones run() y redirigir la salida
def ejecutar_run(funcion_run):
    # Obtener los parámetros necesarios
    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
    codigo_columna_maestra = obtener_codigo_idioma_por_nombre(codigo_columna_maestra_var.get())
    codigo_idioma = obtener_codigo_idioma_por_nombre(idioma_var.get())
    codigo_idioma2 = obtener_codigo_idioma_por_nombre(idioma_var2.get())

    # Obtener los índices de los idiomas
    indice_seleccionado = idiomas_lista.index((idioma_var.get(), codigo_idioma))
    indice_seleccionado2 = idiomas_lista.index((idioma_var2.get(), codigo_idioma2))

    # Redirigir stdout
    original_stdout = sys.stdout
    sys.stdout = RedirectText(output_text)

    try:
        # Ejecutar la función correspondiente
        if funcion_run == x1_importar_to_master.run:
            print("Ejecutando x1_importar_to_master.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra)
        elif funcion_run == x2_master_export2translate.run:
            print("Ejecutando x2_master_export2translate.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
        elif funcion_run == x3_llm_auto_translate.run:
            traducir_todo = messagebox.askyesno("Traducir todo", "¿Desea traducir todas las celdas?")
            print("Ejecutando x3_llm_auto_translate.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, traducir_todo)
        elif funcion_run == x4_integrate_translates_to_master.run:
            print("Ejecutando x4_integrate_translates_to_master.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, 0.5)
        elif funcion_run == x5_complete_empty_cells_master.run:
            print("Ejecutando x5_complete_empty_cells_master.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, indice_seleccionado2)
        elif funcion_run == x6_update_from_master.run:
            print("Ejecutando x6_update_from_master.run()")
            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
    finally:
        # Restaurar stdout
        sys.stdout = original_stdout
        guardar_configuracion()  # Guardar el contenido del cuadro de texto

# Crear los botones con el mismo ancho
button_width = 70
paso1 = tk.Button(ventana, text="1 - Importar al Master", command=lambda: threading.Thread(target=ejecutar_run, args=(x1_importar_to_master.run,)).start(), width=button_width)
paso2 = tk.Button(ventana, text="2 - Exportar Idioma a 2_master_export2translate.xlsx.", command=lambda: threading.Thread(target=ejecutar_run, args=(x2_master_export2translate.run,)).start(), width=button_width)
paso3 = tk.Button(ventana, text="3 - Traducir y generar 3_master_export2translate_translated.xlsx.", command=lambda: threading.Thread(target=ejecutar_run, args=(x3_llm_auto_translate.run,)).start(), width=button_width)
paso4 = tk.Button(ventana, text="4 - Integrar las traducciones al 1_hmi_master_translates.", command=lambda: threading.Thread(target=ejecutar_run, args=(x4_integrate_translates_to_master.run,)).start(), width=button_width)
paso5 = tk.Button(ventana, text="5 - Completar en 1_hmi_master_translates el idioma seleccionado usando el segundo idioma.", command=lambda: threading.Thread(target=ejecutar_run, args=(x5_complete_empty_cells_master.run,)).start(), width=button_width)
paso6 = tk.Button(ventana, text="6 - Exportar usando un archivo exportado desde TIA Portal usando 1_hmi_master_translates.", command=lambda: threading.Thread(target=ejecutar_run, args=(x6_update_from_master.run,)).start(), width=button_width)

# Ubicar los botones en la ventana
paso1.pack(pady=(10,2))
paso2.pack(pady=2)
paso3.pack(pady=2)
paso4.pack(pady=2)
paso5.pack(pady=2)
paso6.pack(pady=2)

# Crear un Frame para el cuadro de texto, los scrollbars y el botón
frame_texto = tk.Frame(ventana)
frame_texto.pack(fill='both', expand=True, pady=10)

# Crear los scrollbars
scrollbar_vertical = tk.Scrollbar(frame_texto, orient='vertical')
scrollbar_horizontal = tk.Scrollbar(frame_texto, orient='horizontal')

# Crear la caja de texto para mostrar la salida
output_text = tk.Text(
    frame_texto,
    wrap='none',
    yscrollcommand=scrollbar_vertical.set,
    xscrollcommand=scrollbar_horizontal.set
)

# Configurar los scrollbars
scrollbar_vertical.config(command=output_text.yview)
scrollbar_horizontal.config(command=output_text.xview)

# Crear el botón para borrar el contenido
boton_limpiar = tk.Button(frame_texto, text="Borrar contenido", command=lambda: limpiar_texto())

# Ubicar los widgets en frame_texto usando grid
output_text.grid(row=0, column=0, sticky='nsew')
scrollbar_vertical.grid(row=0, column=1, sticky='ns')
scrollbar_horizontal.grid(row=1, column=0, sticky='ew')
boton_limpiar.grid(row=1, column=1, padx=5, pady=5)

# Configurar la expansión de filas y columnas
frame_texto.grid_rowconfigure(0, weight=1)
frame_texto.grid_columnconfigure(0, weight=1)

# Función para borrar el contenido del cuadro de texto
def limpiar_texto():
    output_text.delete('1.0', tk.END)
    guardar_configuracion()

# Cargar las opciones guardadas al iniciar
cargar_configuracion()

# Cargar el contenido del cuadro de texto desde la configuración
def cargar_texto():
    config = configparser.ConfigParser()
    if os.path.exists(config_file):
        config.read(config_file)
        texto = config.get('TextContent', 'output_text', fallback='')
        output_text.insert('1.0', texto)

cargar_texto()

# Guardar la configuración al cerrar la ventana
def on_closing():
    guardar_configuracion()
    ventana.destroy()

ventana.protocol("WM_DELETE_WINDOW", on_closing)

# Iniciar el bucle principal de la interfaz
ventana.mainloop()