#!/usr/bin/env python3

import gi

gi.require_version("Gtk", "3.0")
gi.require_version("Gio", "2.0")
from gi.repository import Gtk, Gio, GLib


class PantallasConfigDialog(Gtk.Window):
    def __init__(self):
        super().__init__(title="Configuración del Indicador de Resolución de pantalla")
        self.set_default_size(400, 300)

        # Establecer icono de la ventana
        icon_name = "vx-pantallas-conmutador-orange"
        self.set_icon_name(icon_name)

        self.schema = "org.vitalinux.pantallas-conmutador"
        self.keys = ["r16-9", "r4-3"]

        # Obtener valores iniciales
        self.valores = self.obtener_valores_gsettings(self.schema, self.keys)

        # Crear contenedor principal
        vbox = Gtk.VBox()
        self.add(vbox)

        # Crear pestañas
        notebook = Gtk.Notebook()
        vbox.pack_start(notebook, True, True, 0)

        for i, key in enumerate(self.keys):
            # Crear pestaña para cada key
            page = Gtk.VBox()
            notebook.append_page(page, Gtk.Label(label=key))

            # Agregar un espacio vertical al principio de la pestaña
            page.pack_start(Gtk.Label(), False, False, 5)

            # Crear campos de entrada para cada valor de la opción
            for j, opcion in enumerate(self.valores[key]):
                titulo, _, resolucion, _ = opcion.split(":")

                # Agregar label para el par de campos
                label_opcion = Gtk.Label(label=f"Opción de resolución {j + 1}:")
                page.pack_start(label_opcion, False, False, 0)  # Agregar label al VBox

                # Crear un contenedor horizontal para los campos
                hbox = Gtk.HBox()
                hbox.set_margin_start(10)  # Margen izquierdo para el hbox
                page.pack_start(hbox, False, False, 0)

                # Agregar campos de entrada para cada valor de la opción
                label_titulo = Gtk.Label(label="Modo:")
                entry_titulo = Gtk.Entry()
                entry_titulo.set_text(titulo)
                entry_titulo.connect(
                    "changed", self.on_entry_changed, f"{key}_{j}_titulo"
                )

                label_resolucion = Gtk.Label(label="Resolución:")
                entry_resolucion = Gtk.Entry()
                entry_resolucion.set_text(resolucion)
                entry_resolucion.connect(
                    "changed", self.on_entry_changed, f"{key}_{j}_resolucion"
                )

                # Agregar campos al contenedor horizontal con espacio
                hbox.pack_start(
                    label_titulo, False, False, 5
                )  # Espacio entre label y entry
                hbox.pack_start(
                    entry_titulo, False, False, 5
                )  # Espacio entre label y entry
                hbox.pack_start(
                    label_resolucion, False, False, 5
                )  # Espacio entre label y entry
                hbox.pack_start(
                    entry_resolucion, True, True, 5
                )  # Espacio entre label y entry, y expandir el entry a la derecha

                # Agregar un espacio vertical entre las opciones
                page.pack_start(
                    Gtk.Label(), False, False, 5
                )  # Margen vertical entre opciones

        # Crear contenedor horizontal para los botones
        hbox_buttons = Gtk.HBox()
        vbox.pack_start(hbox_buttons, False, False, 0)

        # Crear botón Aceptar
        button_aceptar = Gtk.Button(label="Aceptar")
        button_aceptar.connect("clicked", self.on_button_aceptar)
        hbox_buttons.pack_start(button_aceptar, False, False, 0)

        # Crear botón Cancelar
        button_cancelar = Gtk.Button(label="Cancelar")
        button_cancelar.connect("clicked", self.on_button_cancelar)
        hbox_buttons.pack_start(button_cancelar, False, False, 0)

        # Centrado de los botones en el contenedor horizontal
        hbox_buttons.set_homogeneous(True)  # Distribución uniforme de los botones
        hbox_buttons.set_spacing(10)  # Espacio entre los botones

        # Mostrar la ventana
        self.connect("destroy", Gtk.main_quit)
        self.show_all()

    # ... (resto del código)

    def obtener_valores_gsettings(self, esquema, keys):
        """Obtiene los valores de un esquema GSettings para las claves especificadas
        y los devuelve como un diccionario.

        Args:
            esquema: El nombre del esquema GSettings.
            keys: Una lista de claves del esquema GSettings a obtener.

        Returns:
            Un diccionario con los valores del esquema GSettings para las claves especificadas.
        """
        settings = Gio.Settings.new(esquema)
        valores = {}
        for key in keys:
            valores[key] = settings.get_value(key)
            # Convertir el Gio.Variant a una lista de strings
            valores[key] = [str(v) for v in valores[key]]
        return valores

    def actualizar_gsettings(self, esquema, valores):
        """Actualiza los valores de un esquema GSettings.

        Args:
            esquema: El nombre del esquema GSettings.
            valores: Un diccionario con los nuevos valores.
        """
        settings = Gio.Settings.new(esquema)
        for key, valor in valores.items():
            # Crear un array de GLib.Variant a partir de la lista de strings
            variant_list = [GLib.Variant.new_string(v) for v in valor]
            # Convertir la lista de GLib.Variant a un GLib.Variant
            variant = GLib.Variant.new_array(GLib.VariantType.new("s"), variant_list)
            settings.set_value(key, variant)

    def on_entry_changed(self, entry, key):
        """Maneja el evento "changed" de los campos de entrada."""
        # Actualiza el valor en el diccionario de valores
        valor = entry.get_text()
        partes = key.split("_")
        key_principal = partes[0]
        indice = int(partes[1])
        campo = partes[2]  # Obtener el nombre del campo ("titulo" o "resolucion")

        # Obtener la lista actual del diccionario
        lista_actual = self.valores[key_principal]

        # Modificar la lista (asegurarse de que todos los elementos sean strings)
        if campo == "titulo":
            lista_actual[indice] = ":".join(
                [valor, "auto", *lista_actual[indice].split(":")[2:]]
            )
        elif campo == "resolucion":
            lista_actual[indice] = ":".join(
                [
                    *lista_actual[indice].split(":")[:1],
                    "auto",
                    valor,
                    *lista_actual[indice].split(":")[3:],
                ]
            )

        # Actualizar el diccionario con la lista modificada
        self.valores[key_principal] = lista_actual

    def on_button_aceptar(self, button):
        """Maneja el evento "clicked" del botón Aceptar."""
        # Actualizar los valores de GSettings
        self.actualizar_gsettings(self.schema, self.valores)

        # Cerrar la ventana
        self.destroy()

    def on_button_cancelar(self, button):
        """Maneja el evento "clicked" del botón Cancelar."""
        # Cerrar la ventana sin guardar cambios
        self.destroy()


if __name__ == "__main__":
    win = PantallasConfigDialog()
    Gtk.main()
