#!/usr/bin/env python3

import dbus
import dbus.mainloop.glib
import os
from gi.repository import GLib

# Define the paths to the PNG icons
ICON_PATHS = {
    "nvidia": "/home/teraflops/Icons/nvidia-icon.svg",
    "integrated": "/home/teraflops/Icons/amd.png",
}

# Function to interpret the numerical status into a clearer message
def interpret_gpu_status(status):
    if status == 0:
        return "nvidia"
    elif status == 1:
        return "integrated"
    else:
        return None  # Ignore "switching mode" and other unknown statuses

# Function to send the signal using `os.system()`
def send_signal_to_waybar():
    try:
        print("Enviando señal RTMIN+3 a Waybar usando os.system")  # Mensaje de depuración
        os.system("/usr/bin/pkill -RTMIN+3 waybar")
    except Exception as e:
        print(f"Error al enviar la señal con os.system: {e}")

# Función para escribir el script shell con la ruta de la imagen y el tooltip en /tmp/gpu.sh
def write_gpu_icon_script(status_message):
    try:
        icon_path = ICON_PATHS.get(status_message)
        if icon_path:
            # Define el texto del tooltip basado en el estado
            tooltip_text = f"GPU: {status_message.capitalize()}"

            print(f"Escribiendo en /tmp/gpu.sh:")
            print(f"Ruta de la imagen: {icon_path}")
            print(f"Texto del tooltip: {tooltip_text}")

            # Escribe dos líneas: una para la ruta de la imagen y otra para el tooltip
            with open("/tmp/gpu.sh", "w") as file:
                file.write("#!/bin/sh\n")
                file.write(f'echo "{icon_path}"\n')
                file.write(f'echo "{tooltip_text}"\n')

            # Hace que el script sea ejecutable
            os.chmod("/tmp/gpu.sh", 0o755)
            print("Script /tmp/gpu.sh actualizado correctamente.")
        else:
            print(f"No se encontró un icono para el estado: {status_message}")
    except Exception as e:
        print(f"Error al escribir el script en /tmp/gpu.sh: {e}")

# Callback para `NotifyGfxStatus`
def on_notify_gfx_status(status):
    print(f"Callback `on_notify_gfx_status` invocado con status: {status}")  # Depuración
    status_message = interpret_gpu_status(status)

    # Si el estado no es "nvidia" o "integrated", ignorarlo
    if status_message:
        print(f"Estado de GPU cambiado: {status_message}")

        # Guarda el script shell con la ruta de la imagen y el tooltip en /tmp/gpu.sh
        write_gpu_icon_script(status_message)

        # Envía la señal a Waybar usando os.system
        send_signal_to_waybar()
    else:
        print("Estado intermedio detectado, no se tomará ninguna acción.")

# Callback para `NotifyGfx`
def on_notify_gfx(vendor):
    print(f"Callback `on_notify_gfx` invocado con vendor: {vendor}")

# Callback para `NotifyAction`
def on_notify_action(action):
    print(f"Callback `on_notify_action` invocado con action: {action}")

# Inicializa el loop de D-Bus
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

# Conecta al bus del sistema y obtiene el objeto
bus = dbus.SystemBus()
proxy = bus.get_object("org.supergfxctl.Daemon", "/org/supergfxctl/Gfx")

# Suscribirse a las señales `NotifyGfxStatus`, `NotifyGfx` y `NotifyAction`
bus.add_signal_receiver(on_notify_gfx_status,
                        dbus_interface="org.supergfxctl.Daemon",
                        signal_name="NotifyGfxStatus")

bus.add_signal_receiver(on_notify_gfx,
                        dbus_interface="org.supergfxctl.Daemon",
                        signal_name="NotifyGfx")

bus.add_signal_receiver(on_notify_action,
                        dbus_interface="org.supergfxctl.Daemon",
                        signal_name="NotifyAction")

print("Monitoreando señales de GPU...")

# Inicia el loop principal
loop = GLib.MainLoop()
loop.run()