#!/bin/bash

# ======================================================================
# Archivo:       nvidiaconfig
# Ruta:          /usr/local/bin/
# Autor:         Charlie Martínez® <cmartinez@quirinux.org>
# Licencia:      https://www.gnu.org/licenses/gpl-2.0.txt
# Propósito:     Configurador gráfico para Nvidia
# Distribución:  Quirinux 2.x (Devuan Daedalus)
# ======================================================================

#
# Copyright (c) 2019-2025 Charlie Martínez, derechos reservados.
# Licencia: https://www.gnu.org/licenses/gpl-2.0.txt
# Usos autorizados y no autorizados de la marca Quirinux:
# Ver https://www.quirinux.org/aviso-legal
#

OWN_PKG="quirinux-nvidia-config"

# ----------------------------------------------------------------------
#  Preconfiguración de debconf: aceptar licencias sin interacción
# ----------------------------------------------------------------------
preconfigure_debconf() {
    if command -v debconf-set-selections >/dev/null 2>&1; then
        {
            echo "nvidia-driver                    nvidia/license-accepted boolean true"
            echo "nvidia-driver                    nvidia/license-accepted seen   true"
            echo "nvidia-tesla-470-driver          nvidia/license-accepted boolean true"
            echo "nvidia-tesla-470-driver          nvidia/license-accepted seen   true"
            echo "nvidia-legacy-390xx-driver       nvidia/license-accepted boolean true"
            echo "nvidia-legacy-390xx-driver       nvidia/license-accepted seen   true"
            echo "cuda-drivers                     nvidia/license-accepted boolean true"
            echo "cuda-drivers                     nvidia/license-accepted seen   true"
            echo "nvidia-support                   nvidia/license-accepted boolean true"
            echo "nvidia-support                   nvidia/license-accepted seen   true"
        } | debconf-set-selections 2>/dev/null || true
    fi
}

# ----------------------------------------------------------------------
#  Detección de idioma
# ----------------------------------------------------------------------
detect_lang() {
    local lang="${LANG:-${LANGUAGE:-en}}"
    lang="${lang:0:2}"
    case "$lang" in
        es) echo "es" ;;
        gl) echo "gl" ;;
        de) echo "de" ;;
        ru) echo "ru" ;;
        pt) echo "pt" ;;
        fr) echo "fr" ;;
        it) echo "it" ;;
        hu) echo "hu" ;;
        *)  echo "en" ;;
    esac
}

LANG_CODE=$(detect_lang)

# ----------------------------------------------------------------------
#  Traducciones
# ----------------------------------------------------------------------
t() {
    local key="$1"
    case "${LANG_CODE}:${key}" in

        es:need_root)   echo "Este script debe ejecutarse con permisos de administración." ;;
        gl:need_root)   echo "Este script debe executarse con permisos de administración." ;;
        de:need_root)   echo "Dieses Skript muss mit Administratorrechten ausgeführt werden." ;;
        ru:need_root)   echo "Этот скрипт должен быть запущен с правами администратора." ;;
        pt:need_root)   echo "Este script deve ser executado com permissões de administrador." ;;
        fr:need_root)   echo "Ce script doit être exécuté avec des droits d'administrateur." ;;
        it:need_root)   echo "Questo script deve essere eseguito con i permessi di amministratore." ;;
        hu:need_root)   echo "Ezt a szkriptet rendszergazdai jogosultságokkal kell futtatni." ;;
        *:need_root)    echo "This script must be run with administrator privileges." ;;

        es:need_internet)   echo "Este programa requiere conexión a internet." ;;
        gl:need_internet)   echo "Este programa require conexión a internet." ;;
        de:need_internet)   echo "Dieses Programm erfordert eine Internetverbindung." ;;
        ru:need_internet)   echo "Для работы программы необходимо подключение к интернету." ;;
        pt:need_internet)   echo "Este programa requer ligação à internet." ;;
        fr:need_internet)   echo "Ce programme nécessite une connexion internet." ;;
        it:need_internet)   echo "Questo programma richiede una connessione a internet." ;;
        hu:need_internet)   echo "Ehhez a programhoz internetkapcsolat szükséges." ;;
        *:need_internet)    echo "This program requires an internet connection." ;;

        es:no_nvidia)   echo "No se detectó hardware Nvidia en este sistema." ;;
        gl:no_nvidia)   echo "Non se detectou hardware Nvidia neste sistema." ;;
        de:no_nvidia)   echo "Keine Nvidia-Hardware auf diesem System gefunden." ;;
        ru:no_nvidia)   echo "Оборудование Nvidia не обнаружено в этой системе." ;;
        pt:no_nvidia)   echo "Nenhum hardware Nvidia detetado neste sistema." ;;
        fr:no_nvidia)   echo "Aucun matériel Nvidia détecté sur ce système." ;;
        it:no_nvidia)   echo "Nessun hardware Nvidia rilevato su questo sistema." ;;
        hu:no_nvidia)   echo "Nem találtunk Nvidia hardvert ezen a rendszeren." ;;
        *:no_nvidia)    echo "No Nvidia hardware detected on this system." ;;

        es:gpu_found)   echo "Hardware Nvidia detectado" ;;
        gl:gpu_found)   echo "Hardware Nvidia detectado" ;;
        de:gpu_found)   echo "Nvidia-Hardware erkannt" ;;
        ru:gpu_found)   echo "Обнаружено оборудование Nvidia" ;;
        pt:gpu_found)   echo "Hardware Nvidia detetado" ;;
        fr:gpu_found)   echo "Matériel Nvidia détecté" ;;
        it:gpu_found)   echo "Hardware Nvidia rilevato" ;;
        hu:gpu_found)   echo "Nvidia hardver felismerve" ;;
        *:gpu_found)    echo "Nvidia hardware detected" ;;

        es:select_driver)   echo "Selecciona el controlador a instalar:" ;;
        gl:select_driver)   echo "Selecciona o controlador a instalar:" ;;
        de:select_driver)   echo "Wähle den zu installierenden Treiber:" ;;
        ru:select_driver)   echo "Выберите драйвер для установки:" ;;
        pt:select_driver)   echo "Selecione o controlador a instalar:" ;;
        fr:select_driver)   echo "Sélectionnez le pilote à installer :" ;;
        it:select_driver)   echo "Seleziona il driver da installare:" ;;
        hu:select_driver)   echo "Válassza ki a telepítendő illesztőprogramot:" ;;
        *:select_driver)    echo "Select the driver to install:" ;;

        es:drv_recommended) echo "Privativo" ;;
        gl:drv_recommended) echo "Privativo" ;;
        de:drv_recommended) echo "Proprietär" ;;
        ru:drv_recommended) echo "Проприетарный" ;;
        pt:drv_recommended) echo "Privativo" ;;
        fr:drv_recommended) echo "Propriétaire" ;;
        it:drv_recommended) echo "Proprietario" ;;
        hu:drv_recommended) echo "Proprietáris" ;;
        *:drv_recommended)  echo "Proprietary" ;;

        es:drv_legacy)  echo "Heredado (legacy)" ;;
        gl:drv_legacy)  echo "Herdado (legacy)" ;;
        de:drv_legacy)  echo "Veraltet (Legacy)" ;;
        ru:drv_legacy)  echo "Устаревший (legacy)" ;;
        pt:drv_legacy)  echo "Legado (legacy)" ;;
        fr:drv_legacy)  echo "Hérité (legacy)" ;;
        it:drv_legacy)  echo "Legacy" ;;
        hu:drv_legacy)  echo "Örökölt (legacy)" ;;
        *:drv_legacy)   echo "Legacy" ;;

        es:drv_open)    echo "Código abierto (nouveau)" ;;
        gl:drv_open)    echo "Código aberto (nouveau)" ;;
        de:drv_open)    echo "Open-Source (nouveau)" ;;
        ru:drv_open)    echo "Открытый (nouveau)" ;;
        pt:drv_open)    echo "Código aberto (nouveau)" ;;
        fr:drv_open)    echo "Open-source (nouveau)" ;;
        it:drv_open)    echo "Open-source (nouveau)" ;;
        hu:drv_open)    echo "Nyílt forráskódú (nouveau)" ;;
        *:drv_open)     echo "Open-source (nouveau)" ;;

        # ------------------------------------------------------------------
        #  Aviso para hardware LEGACY_340XX
        #  Nvidia retiró el soporte del driver 340xx, por lo que su módulo
        #  de kernel no compila con los kernels actuales de Quirinux.
        #  Se informa al usuario y se continúa con nouveau.
        # ------------------------------------------------------------------
        es:no_privativo_340xx)
            echo "CONTROLADOR PRIVATIVO NO DISPONIBLE\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia retiró el soporte oficial para esta GPU\n\
y el controlador privativo 340xx ya no es compatible\n\
con los kernels Linux actuales.\n\
\n\
El único controlador estable para este hardware es\n\
nouveau (código abierto), que funciona correctamente\n\
para uso de escritorio.\n\
\n\
El sistema continuará con la instalación/reinstalación de nouveau." ;;

        gl:no_privativo_340xx)
            echo "CONTROLADOR PRIVATIVO NON DISPOÑIBLE\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia retirou o soporte oficial para esta GPU\n\
e o controlador privativo 340xx xa non é compatible\n\
cos kernels Linux actuais.\n\
\n\
O único controlador estable para este hardware é\n\
nouveau (código aberto), que funciona correctamente\n\
para uso de escritorio.\n\
\n\
O sistema continuará coa instalación/reinstalación de nouveau." ;;

        de:no_privativo_340xx)
            echo "PROPRIETÄRER TREIBER NICHT VERFÜGBAR\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia hat den offiziellen Support für diese GPU eingestellt.\n\
Der proprietäre Treiber 340xx ist nicht mehr kompatibel\n\
mit den aktuellen Linux-Kerneln.\n\
\n\
Der einzige stabile Treiber für diese Hardware ist\n\
nouveau (Open-Source), der für den Desktop-Einsatz\n\
korrekt funktioniert.\n\
\n\
Die Installation/Neuinstallation von nouveau wird fortgesetzt." ;;

        ru:no_privativo_340xx)
            echo "ПРОПРИЕТАРНЫЙ ДРАЙВЕР НЕДОСТУПЕН\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia прекратила официальную поддержку этого GPU.\n\
Проприетарный драйвер 340xx больше не совместим\n\
с актуальными ядрами Linux.\n\
\n\
Единственный стабильный драйвер для этого оборудования —\n\
nouveau (открытый исходный код), который корректно\n\
работает для настольного использования.\n\
\n\
Будет выполнена установка/переустановка nouveau." ;;

        pt:no_privativo_340xx)
            echo "CONTROLADOR PRIVATIVO INDISPONÍVEL\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
A Nvidia retirou o suporte oficial para esta GPU\n\
e o controlador privativo 340xx já não é compatível\n\
com os kernels Linux atuais.\n\
\n\
O único controlador estável para este hardware é\n\
o nouveau (código aberto), que funciona corretamente\n\
para uso em ambiente de trabalho.\n\
\n\
A instalação/reinstalação do nouveau continuará." ;;

        fr:no_privativo_340xx)
            echo "PILOTE PROPRIÉTAIRE INDISPONIBLE\n\
\n\
GPU : ${GPU_MODEL}\n\
\n\
Nvidia a mis fin au support officiel de ce GPU.\n\
Le pilote propriétaire 340xx n'est plus compatible\n\
avec les noyaux Linux actuels.\n\
\n\
Le seul pilote stable pour ce matériel est\n\
nouveau (open-source), qui fonctionne correctement\n\
pour un usage bureautique.\n\
\n\
L'installation/réinstallation de nouveau va continuer." ;;

        it:no_privativo_340xx)
            echo "DRIVER PROPRIETARIO NON DISPONIBILE\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia ha ritirato il supporto ufficiale per questa GPU\n\
e il driver proprietario 340xx non è più compatibile\n\
con i kernel Linux attuali.\n\
\n\
L'unico driver stabile per questo hardware è\n\
nouveau (open-source), che funziona correttamente\n\
per l'uso desktop.\n\
\n\
L'installazione/reinstallazione di nouveau continuerà." ;;

        hu:no_privativo_340xx)
            echo "PROPRIETÁRIS ILLESZTŐPROGRAM NEM ELÉRHETŐ\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Az Nvidia megszüntette a hivatalos támogatást ehhez a GPU-hoz.\n\
A proprietáris 340xx illesztőprogram már nem kompatibilis\n\
az aktuális Linux-kernelekkel.\n\
\n\
Az egyetlen stabil illesztőprogram ehhez a hardverhez\n\
a nouveau (nyílt forráskódú), amely megfelelően működik\n\
asztali használatra.\n\
\n\
A nouveau telepítése/újratelepítése folytatódik." ;;

        *:no_privativo_340xx)
            echo "PROPRIETARY DRIVER NOT AVAILABLE\n\
\n\
GPU: ${GPU_MODEL}\n\
\n\
Nvidia has withdrawn official support for this GPU.\n\
The proprietary 340xx driver is no longer compatible\n\
with the current Linux kernels.\n\
\n\
The only stable driver for this hardware is\n\
nouveau (open-source), which works correctly\n\
for desktop use.\n\
\n\
Installation/reinstallation of nouveau will continue." ;;

        es:confirm_install) echo "¿Instalar el siguiente controlador?" ;;
        gl:confirm_install) echo "Instalar o seguinte controlador?" ;;
        de:confirm_install) echo "Folgenden Treiber installieren?" ;;
        ru:confirm_install) echo "Установить следующий драйвер?" ;;
        pt:confirm_install) echo "Instalar o seguinte controlador?" ;;
        fr:confirm_install) echo "Installer le pilote suivant ?" ;;
        it:confirm_install) echo "Installare il seguente driver?" ;;
        hu:confirm_install) echo "Telepítsük a következő illesztőprogramot?" ;;
        *:confirm_install)  echo "Install the following driver?" ;;

        es:confirm_switch_to_open)
            echo "Se desinstalarán los controladores privativos\n\
actualmente instalados y se instalarán los\n\
controladores de código abierto (nouveau).\n\n¿Deseas continuar?" ;;
        gl:confirm_switch_to_open)
            echo "Desinstalaranse os controladores privativos\n\
instalados e instalaranse os de código aberto (nouveau).\n\n¿Desexas continuar?" ;;
        de:confirm_switch_to_open)
            echo "Die proprietären Treiber werden entfernt\n\
und durch nouveau ersetzt.\n\nMöchtest du fortfahren?" ;;
        ru:confirm_switch_to_open)
            echo "Проприетарные драйверы будут удалены\n\
и заменены на nouveau.\n\nПродолжить?" ;;
        pt:confirm_switch_to_open)
            echo "Os controladores privativos serão removidos\n\
e substituídos pelo nouveau.\n\nDeseja continuar?" ;;
        fr:confirm_switch_to_open)
            echo "Les pilotes propriétaires seront supprimés\n\
et remplacés par nouveau.\n\nVoulez-vous continuer ?" ;;
        it:confirm_switch_to_open)
            echo "I driver proprietari verranno rimossi\n\
e sostituiti con nouveau.\n\nContinuare?" ;;
        hu:confirm_switch_to_open)
            echo "A proprietáris illesztőprogramok eltávolításra kerülnek\n\
és nouveau váltja fel őket.\n\nFolytatja?" ;;
        *:confirm_switch_to_open)
            echo "The proprietary drivers will be removed\n\
and replaced with nouveau.\n\nDo you want to continue?" ;;

        es:confirm_switch_to_prop)
            echo "Se desinstalarán los controladores de código\n\
abierto (nouveau) y se instalarán los privativos.\n\n¿Deseas continuar?" ;;
        gl:confirm_switch_to_prop)
            echo "Desinstalaranse os de código aberto (nouveau)\n\
e instalaranse os privativos.\n\n¿Desexas continuar?" ;;
        de:confirm_switch_to_prop)
            echo "Die nouveau-Treiber werden entfernt\n\
und durch proprietäre Treiber ersetzt.\n\nMöchtest du fortfahren?" ;;
        ru:confirm_switch_to_prop)
            echo "Nouveau будет удалён\n\
и заменён проприетарными драйверами.\n\nПродолжить?" ;;
        pt:confirm_switch_to_prop)
            echo "O nouveau será removido\n\
e substituído pelos controladores privativos.\n\nDeseja continuar?" ;;
        fr:confirm_switch_to_prop)
            echo "Le pilote nouveau sera supprimé\n\
et remplacé par des pilotes propriétaires.\n\nVoulez-vous continuer ?" ;;
        it:confirm_switch_to_prop)
            echo "Il driver nouveau verrà rimosso\n\
e sostituito con driver proprietari.\n\nContinuare?" ;;
        hu:confirm_switch_to_prop)
            echo "A nouveau eltávolításra kerül\n\
és proprietáris illesztőprogram váltja fel.\n\nFolytatja?" ;;
        *:confirm_switch_to_prop)
            echo "The nouveau driver will be removed\n\
and replaced with proprietary drivers.\n\nDo you want to continue?" ;;

        es:removing_conflict)   echo "Eliminando controladores en conflicto..." ;;
        gl:removing_conflict)   echo "Eliminando controladores en conflito..." ;;
        de:removing_conflict)   echo "Entferne konfliktverursachende Treiber..." ;;
        ru:removing_conflict)   echo "Удаление конфликтующих драйверов..." ;;
        pt:removing_conflict)   echo "A remover controladores em conflito..." ;;
        fr:removing_conflict)   echo "Suppression des pilotes en conflit..." ;;
        it:removing_conflict)   echo "Rimozione driver in conflitto..." ;;
        hu:removing_conflict)   echo "Ütköző illesztőprogramok eltávolítása..." ;;
        *:removing_conflict)    echo "Removing conflicting drivers..." ;;

        es:adding_nonfree)  echo "Añadiendo repositorios contrib non-free..." ;;
        gl:adding_nonfree)  echo "Engadindo repositorios contrib non-free..." ;;
        de:adding_nonfree)  echo "Füge contrib non-free hinzu..." ;;
        ru:adding_nonfree)  echo "Добавление contrib non-free..." ;;
        pt:adding_nonfree)  echo "A adicionar contrib non-free..." ;;
        fr:adding_nonfree)  echo "Ajout de contrib non-free..." ;;
        it:adding_nonfree)  echo "Aggiunta di contrib non-free..." ;;
        hu:adding_nonfree)  echo "Contrib non-free hozzáadása..." ;;
        *:adding_nonfree)   echo "Adding contrib non-free to package sources..." ;;

        es:updating_repos)  echo "Actualizando repositorios de paquetes..." ;;
        gl:updating_repos)  echo "Actualizando repositorios de paquetes..." ;;
        de:updating_repos)  echo "Paketquellen werden aktualisiert..." ;;
        ru:updating_repos)  echo "Обновление репозиториев пакетов..." ;;
        pt:updating_repos)  echo "A atualizar repositórios de pacotes..." ;;
        fr:updating_repos)  echo "Mise à jour des dépôts de paquets..." ;;
        it:updating_repos)  echo "Aggiornamento dei repository dei pacchetti..." ;;
        hu:updating_repos)  echo "Csomagtárolók frissítése..." ;;
        *:updating_repos)   echo "Updating package repositories..." ;;

        es:installing)  echo "Instalando controladores, por favor espera..." ;;
        gl:installing)  echo "Instalando controladores, agarda por favor..." ;;
        de:installing)  echo "Installiere Treiber, bitte warten..." ;;
        ru:installing)  echo "Установка драйверов, пожалуйста, подождите..." ;;
        pt:installing)  echo "A instalar controladores, aguarde por favor..." ;;
        fr:installing)  echo "Installation des pilotes, veuillez patienter..." ;;
        it:installing)  echo "Installazione driver in corso, attendere..." ;;
        hu:installing)  echo "Illesztőprogramok telepítése, kérjük várjon..." ;;
        *:installing)   echo "Installing drivers, please wait..." ;;

        es:install_ok)  echo "Controladores instalados correctamente.\n\nSe recomienda reiniciar el sistema." ;;
        gl:install_ok)  echo "Controladores instalados correctamente.\n\nRecoméndase reiniciar o sistema." ;;
        de:install_ok)  echo "Treiber erfolgreich installiert.\n\nEin Neustart wird empfohlen." ;;
        ru:install_ok)  echo "Драйверы успешно установлены.\n\nРекомендуется перезагрузить систему." ;;
        pt:install_ok)  echo "Controladores instalados com sucesso.\n\nRecomenda-se reiniciar o sistema." ;;
        fr:install_ok)  echo "Pilotes installés avec succès.\n\nUn redémarrage est recommandé." ;;
        it:install_ok)  echo "Driver installati con successo.\n\nSi consiglia il riavvio del sistema." ;;
        hu:install_ok)  echo "Az illesztőprogramok sikeresen telepítve.\n\nA rendszer újraindítása ajánlott." ;;
        *:install_ok)   echo "Drivers installed successfully.\n\nA system reboot is recommended." ;;

        es:install_fail)    echo "La instalación falló.\nRevisa el log para más detalles." ;;
        gl:install_fail)    echo "A instalación fallou.\nRevisa o log para máis detalles." ;;
        de:install_fail)    echo "Installation fehlgeschlagen.\nSiehe Log für Details." ;;
        ru:install_fail)    echo "Ошибка установки.\nСм. журнал для подробностей." ;;
        pt:install_fail)    echo "A instalação falhou.\nVeja o log para detalhes." ;;
        fr:install_fail)    echo "Échec de l'installation.\nVoir le journal pour les détails." ;;
        it:install_fail)    echo "Installazione fallita.\nVedi il log per i dettagli." ;;
        hu:install_fail)    echo "A telepítés sikertelen.\nRészletekért lásd a naplót." ;;
        *:install_fail)     echo "Installation failed.\nCheck the log for details." ;;

        es:cancelled)   echo "Instalación cancelada por el usuario." ;;
        gl:cancelled)   echo "Instalación cancelada polo usuario." ;;
        de:cancelled)   echo "Installation durch Benutzer abgebrochen." ;;
        ru:cancelled)   echo "Установка отменена пользователем." ;;
        pt:cancelled)   echo "Instalação cancelada pelo utilizador." ;;
        fr:cancelled)   echo "Installation annulée par l'utilisateur." ;;
        it:cancelled)   echo "Installazione annullata dall'utente." ;;
        hu:cancelled)   echo "A telepítést a felhasználó megszakította." ;;
        *:cancelled)    echo "Installation cancelled by user." ;;

        es:detecting)   echo "Detectando hardware Nvidia..." ;;
        gl:detecting)   echo "Detectando hardware Nvidia..." ;;
        de:detecting)   echo "Erkenne Nvidia-Hardware..." ;;
        ru:detecting)   echo "Определение оборудования Nvidia..." ;;
        pt:detecting)   echo "A detetar hardware Nvidia..." ;;
        fr:detecting)   echo "Détection du matériel Nvidia..." ;;
        it:detecting)   echo "Rilevamento hardware Nvidia..." ;;
        hu:detecting)   echo "Nvidia hardver felismerése..." ;;
        *:detecting)    echo "Detecting Nvidia hardware..." ;;

        *:title)        echo "Nvidia-Config" ;;

        es:need_pciutils)   echo "El paquete 'pciutils' es necesario\npero no está instalado. Instalando..." ;;
        gl:need_pciutils)   echo "O paquete 'pciutils' é necesario\npero non está instalado. Instalando..." ;;
        de:need_pciutils)   echo "Das Paket 'pciutils' wird benötigt,\nist aber nicht installiert. Installiere..." ;;
        ru:need_pciutils)   echo "Пакет 'pciutils' необходим,\nно не установлен. Установка..." ;;
        pt:need_pciutils)   echo "O pacote 'pciutils' é necessário\nmas não está instalado. A instalar..." ;;
        fr:need_pciutils)   echo "Le paquet 'pciutils' est nécessaire\nmais pas installé. Installation..." ;;
        it:need_pciutils)   echo "Il pacchetto 'pciutils' è necessario\nma non installato. Installazione..." ;;
        hu:need_pciutils)   echo "A 'pciutils' csomag szükséges,\nde nincs telepítve. Telepítés..." ;;
        *:need_pciutils)    echo "Package 'pciutils' is required\nbut not installed. Installing..." ;;

        es:lbl_model)   echo "Modelo" ;;
        gl:lbl_model)   echo "Modelo" ;;
        de:lbl_model)   echo "Modell" ;;
        ru:lbl_model)   echo "Модель" ;;
        pt:lbl_model)   echo "Modelo" ;;
        fr:lbl_model)   echo "Modèle" ;;
        it:lbl_model)   echo "Modello" ;;
        hu:lbl_model)   echo "Modell" ;;
        *:lbl_model)    echo "Model" ;;

        es:lbl_pci)     echo "ID PCI" ;;
        *:lbl_pci)      echo "PCI ID" ;;

        es:lbl_current) echo "Controlador activo" ;;
        gl:lbl_current) echo "Controlador activo" ;;
        de:lbl_current) echo "Aktueller Treiber" ;;
        ru:lbl_current) echo "Текущий драйвер" ;;
        pt:lbl_current) echo "Controlador atual" ;;
        fr:lbl_current) echo "Pilote actuel" ;;
        it:lbl_current) echo "Driver attuale" ;;
        hu:lbl_current) echo "Jelenlegi illesztőprogram" ;;
        *:lbl_current)  echo "Current driver" ;;

        es:lbl_drv_ver) echo "Versión del controlador" ;;
        gl:lbl_drv_ver) echo "Versión do controlador" ;;
        de:lbl_drv_ver) echo "Treiberversion" ;;
        ru:lbl_drv_ver) echo "Версия драйвера" ;;
        pt:lbl_drv_ver) echo "Versão do controlador" ;;
        fr:lbl_drv_ver) echo "Version du pilote" ;;
        it:lbl_drv_ver) echo "Versione driver" ;;
        hu:lbl_drv_ver) echo "Illesztőprogram verziója" ;;
        *:lbl_drv_ver)  echo "Driver version" ;;

        es:none)    echo "ninguno" ;;
        gl:none)    echo "ningún" ;;
        de:none)    echo "keiner" ;;
        ru:none)    echo "нет" ;;
        pt:none)    echo "nenhum" ;;
        fr:none)    echo "aucun" ;;
        it:none)    echo "nessuno" ;;
        hu:none)    echo "nincs" ;;
        *:none)     echo "none" ;;

        es:btn_cancel)  echo "Cancelar" ;;
        gl:btn_cancel)  echo "Cancelar" ;;
        de:btn_cancel)  echo "Abbrechen" ;;
        ru:btn_cancel)  echo "Отмена" ;;
        pt:btn_cancel)  echo "Cancelar" ;;
        fr:btn_cancel)  echo "Annuler" ;;
        it:btn_cancel)  echo "Annulla" ;;
        hu:btn_cancel)  echo "Mégse" ;;
        *:btn_cancel)   echo "Cancel" ;;

    esac
}

TITLE=$(t title)

# ----------------------------------------------------------------------
#  Zenity helpers
# ----------------------------------------------------------------------
msg_info() {
    zenity --info \
        --title="$TITLE" --text="$1" \
        --ok-label="OK" --width=480 2>/dev/null
}

msg_error() {
    zenity --error \
        --title="$TITLE" --text="$1" \
        --ok-label="OK" --width=480 2>/dev/null
}

msg_question() {
    zenity --question \
        --title="$TITLE" --text="$1" \
        --ok-label="OK" \
        --cancel-label="$(t btn_cancel)" \
        --width=480 2>/dev/null
}

# ----------------------------------------------------------------------
#  1. ROOT CHECK
# ----------------------------------------------------------------------
if [ "$(id -u)" -ne 0 ]; then
    msg_error "$(t need_root)"; exit 1
fi

# ----------------------------------------------------------------------
#  2. INTERNET CHECK
# ----------------------------------------------------------------------
check_internet() {
    for host in 8.8.8.8 1.1.1.1 9.9.9.9; do
        ping -c 1 -W 3 "$host" &>/dev/null && return 0
    done
    return 1
}
if ! check_internet; then
    msg_error "$(t need_internet)"; exit 1
fi

# ----------------------------------------------------------------------
#  WAIT FOR APT LOCK
# ----------------------------------------------------------------------
wait_for_apt() {
    local lock elapsed=0
    local -a LOCK_FILES=(
        /var/lib/dpkg/lock-frontend /var/lib/dpkg/lock
        /var/lib/apt/lists/lock /var/cache/apt/archives/lock
    )
    while true; do
        local locked=false
        for lock in "${LOCK_FILES[@]}"; do
            fuser "$lock" >/dev/null 2>&1 && locked=true && break
        done
        [ "$locked" = false ] && return 0
        sleep 2; elapsed=$((elapsed+2))
        [ "$elapsed" -ge 300 ] && return 1
    done
}

# ----------------------------------------------------------------------
#  3. PCIUTILS CHECK
# ----------------------------------------------------------------------
if ! command -v lspci &>/dev/null; then
    (
        echo "10"; echo "# $(t need_pciutils)"
        wait_for_apt || exit 1
        DEBIAN_FRONTEND=noninteractive apt-get install -y pciutils \
            </dev/null &>/dev/null
        echo "100"
    ) | zenity --progress --title="$TITLE" \
        --text="$(t need_pciutils)" \
        --percentage=0 --auto-close --no-cancel --width=420 2>/dev/null
fi

# ----------------------------------------------------------------------
#  4. DETECT NVIDIA HARDWARE
# ----------------------------------------------------------------------
(
    sleep 0.5; echo "50"; sleep 1; echo "100"
) | zenity --progress --title="$TITLE" \
    --text="$(t detecting)" \
    --percentage=0 --auto-close --no-cancel --width=420 2>/dev/null &

NVIDIA_LINE=$(lspci -nn 2>/dev/null \
    | grep -i "VGA\|3D controller\|Display controller" \
    | grep -i "10de:" | head -1)
[ -z "$NVIDIA_LINE" ] && \
    NVIDIA_LINE=$(lspci -nn 2>/dev/null | grep -i "10de:" | head -1)
wait

if [ -z "$NVIDIA_LINE" ]; then
    msg_error "$(t no_nvidia)"; exit 0
fi

GPU_LINE=$(lspci -nn 2>/dev/null \
    | grep -i "VGA\|3D controller\|Display controller" \
    | grep -i "10de:" | head -1)
[ -z "$GPU_LINE" ] && GPU_LINE="$NVIDIA_LINE"

PCI_ID="unknown"
PCI_MATCH=$(echo "$GPU_LINE" \
    | grep -o '\[10de:[0-9a-fA-F]*\]' \
    | grep -o '[0-9a-fA-F]*\]' | tr -d ']' | head -1)
[ -n "$PCI_MATCH" ] && PCI_ID="10DE:$(echo "$PCI_MATCH" | tr 'a-z' 'A-Z')"

GPU_MODEL="$GPU_LINE"
BRACKET_POS=$(echo "$GPU_LINE" | grep -bo '\[10de:' | head -1 | cut -d: -f1)
if [ -n "$BRACKET_POS" ] && [ "$BRACKET_POS" -gt 0 ]; then
    GPU_MODEL="${GPU_LINE:0:$BRACKET_POS}"
fi
GPU_MODEL=$(echo "$GPU_MODEL" | sed 's/^[^:]*: //' | sed 's/[[:space:]]*$//')

CURRENT_DRV=$(t none)
lsmod 2>/dev/null | grep -q "^nvidia "  && CURRENT_DRV="nvidia (proprietary)"
lsmod 2>/dev/null | grep -q "^nouveau " && CURRENT_DRV="nouveau (open-source)"

# ----------------------------------------------------------------------
#  5. DETERMINAR SERIE Y PAQUETES
# ----------------------------------------------------------------------
MODEL_UPPER=$(echo "$GPU_MODEL" | tr 'a-z' 'A-Z')

is_340xx_gpu() {
    echo "$NVIDIA_LINE" | grep -qi \
        "MCP\|ION\|nForce\|NForce\|"\
"GeForce 3\b\|GeForce 4\b\|GeForce FX\|"\
"GeForce 6\b\|GeForce 7\b\|GeForce 8\b\|GeForce 9\b\|"\
"GeForce 1[0-9][0-9][^0-9]\|"\
"320M\|330M\|9300\|9400\|9500\|9600\|9800\|"\
"GT218\|GT216\|GT215\|G9[0-9]\|G8[0-9]\|C7[0-9]"
}

CHIP_ID=$(echo "$GPU_LINE" \
    | grep -o '\[G[A-Z][0-9]*\]\|\[TU[0-9]*\]\|\[AD[0-9]*\]\|\[GH[0-9]*\]' \
    | tr -d '[]' | head -1)

detect_series() {
    is_340xx_gpu && echo "LEGACY_340XX" && return
    if [ -n "$CHIP_ID" ]; then
        case "${CHIP_ID:0:2}" in
            AD) echo "ADA";     return ;;
            GH) echo "HOPPER";  return ;;
            GA) echo "AMPERE";  return ;;
            TU) echo "TURING";  return ;;
            GP) echo "PASCAL";  return ;;
            GM) echo "MAXWELL"; return ;;
            GK) echo "KEPLER";  return ;;
            GF) echo "FERMI";   return ;;
        esac
    fi
    MODEL_NUM=$(echo "$MODEL_UPPER" \
        | grep -o 'RTX[[:space:]]*[0-9][0-9][0-9][0-9]\|GTX[[:space:]]*[0-9][0-9][0-9][0-9]\|GTX[[:space:]]*[0-9][0-9][0-9]' \
        | grep -o '[0-9]*' | head -1)
    if [ -n "$MODEL_NUM" ]; then
        case "$MODEL_NUM" in
            4???) echo "ADA";     return ;;
            3???) echo "AMPERE";  return ;;
            2???) echo "TURING";  return ;;
            16??) echo "TURING";  return ;;
            10??) echo "PASCAL";  return ;;
            9??)  echo "MAXWELL"; return ;;
            750)  echo "MAXWELL"; return ;;
            7??)  echo "KEPLER";  return ;;
            6??)  echo "KEPLER";  return ;;
            5??)  echo "FERMI";   return ;;
            4??)  echo "FERMI";   return ;;
        esac
    fi
    echo "UNKNOWN"
}

SERIES=$(detect_series)

# ----------------------------------------------------------------------
#  6. HARDWARE LEGACY_340XX: informar y redirigir a nouveau
#     No se ofrece opción de driver privativo porque Nvidia retiró
#     el soporte y el módulo no compila con los kernels de Quirinux.
# ----------------------------------------------------------------------
if [ "$SERIES" = "LEGACY_340XX" ]; then
    if ! msg_question "$(t no_privativo_340xx)"; then
        msg_info "$(t cancelled)"; exit 0
    fi
    # Forzar nouveau como único paquete a instalar
    SELECTED_PKG="xserver-xorg-video-nouveau"
    SERIES="LEGACY_340XX_NOUVEAU"
fi

# ----------------------------------------------------------------------
#  7. ASIGNAR PAQUETES (series con driver privativo disponible)
# ----------------------------------------------------------------------
OPEN_PKG="xserver-xorg-video-nouveau"
RECOMMENDED_PKG=""
RECOMMENDED_KERN=""
LEGACY_PKG=""
DRIVER_VERSION=""

pkg_available() { apt-cache show "$1" >/dev/null 2>&1; }

if [ "$SERIES" != "LEGACY_340XX_NOUVEAU" ]; then
    case "$SERIES" in
        FERMI|KEPLER)
            DRIVER_VERSION="390"
            RECOMMENDED_PKG="nvidia-legacy-390xx-driver"
            RECOMMENDED_KERN="nvidia-legacy-390xx-kernel-dkms"
            ;;
        MAXWELL)
            DRIVER_VERSION="470"
            RECOMMENDED_PKG="nvidia-tesla-470-driver"
            RECOMMENDED_KERN="nvidia-tesla-470-kernel-dkms"
            LEGACY_PKG="nvidia-driver"
            ;;
        ADA|HOPPER|AMPERE|TURING|PASCAL|UNKNOWN)
            DRIVER_VERSION="570"
            VERSIONED_PKG="nvidia-driver-${DRIVER_VERSION}"
            if pkg_available "$VERSIONED_PKG"; then
                RECOMMENDED_PKG="$VERSIONED_PKG"
                VERSIONED_KERN="nvidia-kernel-${DRIVER_VERSION}-dkms"
                pkg_available "$VERSIONED_KERN" && RECOMMENDED_KERN="$VERSIONED_KERN"
            else
                RECOMMENDED_PKG="nvidia-driver"
                RECOMMENDED_KERN="nvidia-kernel-dkms"
            fi
            ;;
    esac
fi

# ----------------------------------------------------------------------
#  Detectar controladores instalados
# ----------------------------------------------------------------------
get_installed_proprietary_pkgs() {
    dpkg-query -W -f='${Package} ${Status}\n' 2>/dev/null \
        | awk '/nvidia/ && /install ok installed/ { print $1 }' \
        | grep -v "nouveau" | grep -v "^${OWN_PKG}$" || true
}

is_nouveau_pkg_installed() {
    dpkg-query -W -f='${Status}\n' "$OPEN_PKG" 2>/dev/null \
        | grep -q "install ok installed"
}

# ----------------------------------------------------------------------
#  8. MENÚ DE SELECCIÓN
#     Solo se muestra si el hardware soporta driver privativo.
#     Para LEGACY_340XX el menú se salta — ya se eligió nouveau arriba.
# ----------------------------------------------------------------------
if [ "$SERIES" != "LEGACY_340XX_NOUVEAU" ]; then

    REC_LABEL="$(t drv_recommended) — ${RECOMMENDED_PKG} (v${DRIVER_VERSION})"
    OPEN_LABEL="$(t drv_open) — ${OPEN_PKG}"

    ZENITY_LIST_ARGS=("TRUE" "$RECOMMENDED_PKG" "$REC_LABEL")
    if [ -n "$LEGACY_PKG" ]; then
        LEG_LABEL="$(t drv_legacy) — ${LEGACY_PKG}"
        ZENITY_LIST_ARGS+=("FALSE" "$LEGACY_PKG" "$LEG_LABEL")
    fi
    ZENITY_LIST_ARGS+=("FALSE" "$OPEN_PKG" "$OPEN_LABEL")

    GPU_INFO_TEXT="<b>$(t lbl_model):</b>        ${GPU_MODEL}\n\
<b>$(t lbl_pci):</b>           ${PCI_ID}\n\
<b>$(t lbl_current):</b>       ${CURRENT_DRV}\n\
<b>$(t lbl_drv_ver):</b>  ${DRIVER_VERSION} (${SERIES})\n\n\
$(t gpu_found).\n$(t select_driver)"

    SELECTED_PKG=$(zenity --list \
        --radiolist \
        --title="$TITLE" \
        --text="$GPU_INFO_TEXT" \
        --column="" --column="pkg" --column="$(t select_driver)" \
        --hide-column=2 --print-column=2 \
        --width=640 --height=360 \
        "${ZENITY_LIST_ARGS[@]}" 2>/dev/null)

    if [ -z "$SELECTED_PKG" ]; then
        msg_info "$(t cancelled)"; exit 0
    fi

    case "$SELECTED_PKG" in
        "$RECOMMENDED_PKG") SELECTED_LABEL="$REC_LABEL" ;;
        "$LEGACY_PKG")      SELECTED_LABEL="${LEG_LABEL:-$SELECTED_PKG}" ;;
        "$OPEN_PKG")        SELECTED_LABEL="$OPEN_LABEL" ;;
        *)                  SELECTED_LABEL="$SELECTED_PKG" ;;
    esac
fi

# ----------------------------------------------------------------------
#  9. DETECTAR CONFLICTOS Y CONFIRMAR
# ----------------------------------------------------------------------
INSTALLED_PROP_PKGS=$(get_installed_proprietary_pkgs)
SWITCHING_TO_OPEN=false
SWITCHING_TO_PROP=false

[ "$SELECTED_PKG" = "$OPEN_PKG" ] \
    && [ -n "$INSTALLED_PROP_PKGS" ] \
    && [ "$SERIES" != "LEGACY_340XX_NOUVEAU" ] \
    && SWITCHING_TO_OPEN=true
[ "$SELECTED_PKG" != "$OPEN_PKG" ] && is_nouveau_pkg_installed && \
    SWITCHING_TO_PROP=true

if [ "$SWITCHING_TO_OPEN" = true ]; then
    if ! msg_question "$(t confirm_switch_to_open)"; then
        msg_info "$(t cancelled)"; exit 0
    fi
elif [ "$SWITCHING_TO_PROP" = true ]; then
    if ! msg_question "$(t confirm_switch_to_prop)"; then
        msg_info "$(t cancelled)"; exit 0
    fi
elif [ "$SERIES" != "LEGACY_340XX_NOUVEAU" ]; then
    if ! msg_question "$(t confirm_install)\n\n<b>${SELECTED_LABEL}</b>"; then
        msg_info "$(t cancelled)"; exit 0
    fi
fi

# ----------------------------------------------------------------------
#  10. INSTALACIÓN
# ----------------------------------------------------------------------
LOGFILE=$(mktemp /tmp/nvidia-config-XXXXXX.log)
RESULT_FILE=$(mktemp /tmp/nvidia-config-result-XXXXXX.tmp)

export DEBIAN_FRONTEND=noninteractive
export DEBCONF_NONINTERACTIVE_SEEN=true
export UCF_FORCE_CONFFNEW=1
export NEEDRESTART_MODE=a
export NEEDRESTART_SUSPEND=1

protect_own_pkg() {
    dpkg-query -W -f='${Status}\n' "$OWN_PKG" 2>/dev/null \
        | grep -q "install ok installed" && \
        apt-mark manual "$OWN_PKG" >>"$LOGFILE" 2>&1 || true
}

remove_proprietary_pkgs() {
    echo "=== Removing proprietary Nvidia packages ===" >>"$LOGFILE"
    local pkgs
    pkgs=$(dpkg-query -W -f='${Package} ${Status}\n' 2>/dev/null \
        | awk '/nvidia/ && /install ok installed/ { print $1 }' \
        | grep -v "nouveau" | grep -v "^${OWN_PKG}$" || true)
    [ -z "$pkgs" ] && echo "Nothing to remove." >>"$LOGFILE" && return 0
    echo "Removing: $pkgs" >>"$LOGFILE"
    # shellcheck disable=SC2086
    apt-get remove --purge -y $pkgs </dev/null >>"$LOGFILE" 2>&1 || true
    protect_own_pkg
    apt-get autoremove -y </dev/null >>"$LOGFILE" 2>&1 || true
}

remove_nouveau_pkg() {
    echo "=== Removing nouveau package ===" >>"$LOGFILE"
    if is_nouveau_pkg_installed; then
        apt-get remove --purge -y "$OPEN_PKG" \
            </dev/null >>"$LOGFILE" 2>&1 || true
        protect_own_pkg
        apt-get autoremove -y </dev/null >>"$LOGFILE" 2>&1 || true
    else
        echo "nouveau not explicitly installed, skipping." >>"$LOGFILE"
    fi
}

install_driver() {
    {
        echo "=== nvidia-config install log ==="
        echo "GPU:     $GPU_MODEL"
        echo "Series:  $SERIES"
        echo "Version: ${DRIVER_VERSION:-nouveau}"
        echo "Package: $SELECTED_PKG"
        echo ""
    } >>"$LOGFILE"

    protect_own_pkg
    preconfigure_debconf >>"$LOGFILE" 2>&1

    # Eliminar conflictos
    if [ "$SWITCHING_TO_OPEN" = true ]; then
        echo "$(t removing_conflict)" >>"$LOGFILE"
        wait_for_apt || { echo "APT lock timeout" >>"$LOGFILE"; return 1; }
        remove_proprietary_pkgs
        rm -f /etc/modprobe.d/nvidia-blacklist-nouveau.conf
    elif [ "$SWITCHING_TO_PROP" = true ]; then
        echo "$(t removing_conflict)" >>"$LOGFILE"
        wait_for_apt || { echo "APT lock timeout" >>"$LOGFILE"; return 1; }
        remove_nouveau_pkg
    fi

    # Activar contrib non-free para privativos
    if [ "$SELECTED_PKG" != "$OPEN_PKG" ]; then
        echo "$(t adding_nonfree)" >>"$LOGFILE"
        if [ -f /etc/apt/sources.list ]; then
            sed -i \
                's/^\(deb .*devuan.*\)\( main\)\([[:space:]]*\)$/\1\2 contrib non-free non-free-firmware/' \
                /etc/apt/sources.list >>"$LOGFILE" 2>&1 || true
        fi
    fi

    # Actualizar repos
    echo "$(t updating_repos)" >>"$LOGFILE"
    wait_for_apt || { echo "APT lock timeout" >>"$LOGFILE"; return 1; }
    apt-get update -q </dev/null >>"$LOGFILE" 2>&1 \
        || { echo "apt-get update failed" >>"$LOGFILE"; return 1; }

    preconfigure_debconf >>"$LOGFILE" 2>&1

    # Construir lista de paquetes
    echo "$(t installing)" >>"$LOGFILE"
    local -a PKGS_TO_INSTALL=("$SELECTED_PKG")

    case "$SELECTED_PKG" in
        nvidia-driver-*)
            [ -n "$RECOMMENDED_KERN" ] && PKGS_TO_INSTALL+=("$RECOMMENDED_KERN") ;;
        "nvidia-driver")
            PKGS_TO_INSTALL+=("nvidia-kernel-dkms") ;;
        "nvidia-tesla-470-driver")
            PKGS_TO_INSTALL+=("nvidia-tesla-470-kernel-dkms") ;;
        "nvidia-legacy-390xx-driver")
            PKGS_TO_INSTALL+=("nvidia-legacy-390xx-kernel-dkms") ;;
        "$OPEN_PKG") : ;;
    esac

    echo "Packages: ${PKGS_TO_INSTALL[*]}" >>"$LOGFILE"

    wait_for_apt || { echo "APT lock timeout" >>"$LOGFILE"; return 1; }

    apt-get install -y --no-install-recommends \
        -o Dpkg::Options::="--force-confnew" \
        -o Dpkg::Options::="--force-confdef" \
        </dev/null \
        "${PKGS_TO_INSTALL[@]}" >>"$LOGFILE" 2>&1 || return 1

    # Blacklist nouveau si se instaló privativo
    if [ "$SELECTED_PKG" != "$OPEN_PKG" ]; then
        printf 'blacklist nouveau\noptions nouveau modeset=0\n' \
            > /etc/modprobe.d/nvidia-blacklist-nouveau.conf
        echo "Nouveau blacklisted." >>"$LOGFILE"
        update-initramfs -u </dev/null >>"$LOGFILE" 2>&1 || true
    fi

    protect_own_pkg
    return 0
}

install_driver \
    && echo "INSTALL_OK"   >"$RESULT_FILE" \
    || echo "INSTALL_FAIL" >"$RESULT_FILE" &
INSTALL_PID=$!

(
    while kill -0 "$INSTALL_PID" 2>/dev/null; do
        echo "# $(t installing)" 2>/dev/null
        sleep 0.5
    done
    echo "100" 2>/dev/null
) | zenity --progress \
    --title="$TITLE" --text="$(t installing)" \
    --pulsate --auto-close --no-cancel --width=420 2>/dev/null

wait "$INSTALL_PID"
RESULT=$(cat "$RESULT_FILE" 2>/dev/null)
rm -f "$RESULT_FILE"

# ----------------------------------------------------------------------
#  11. RESULTADO
# ----------------------------------------------------------------------
if [ "$RESULT" = "INSTALL_OK" ]; then
    msg_info "$(t install_ok)"
else
    zenity --text-info \
        --title="$TITLE — $(t install_fail)" \
        --filename="$LOGFILE" \
        --width=640 --height=400 2>/dev/null
fi

rm -f "$LOGFILE"
exit 0
