#!/usr/bin/python3
# KemmOS Style (1.0.0, 1.0.1 : icônes KemmOS du dock désactivables, logos caméléon ; 1.1.1 : thème du dock réparé ;
# 1.2.0 : traduit en breton et en anglais ; 1.3.0 : logo fastfetch KemmOS en braille, l'ancien au choix ;
# 1.4.0 : palette Dark Pastel par défaut pour Ptyxis ; 1.5.0 : icônes sur le bureau ; 1.6.0 : mode grand confort) : personnaliser l'apparence choisie pour KemmOS — fond d'écran, thème,
# icônes, dock, barre du haut, extensions, terminal et fastfetch, bienvenue — avec un retour aux réglages KemmOS
# par section.
# Ne touche qu'à l'utilisateur courant (gsettings, ~/.config) : aucun mot de passe demandé.
import gettext
import glob
import json
import os
import re
import shutil
import subprocess
import sys

import gi

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("GdkPixbuf", "2.0")
from gi.repository import Adw, Gdk, GdkPixbuf, Gio, GLib, Gtk  # noqa: E402


class _Francais(gettext.NullTranslations):
    """Textes d'origine (français) : pluriel à partir de 2."""

    def ngettext(self, singulier, pluriel, n):
        return singulier if n < 2 else pluriel


def _traduction(domaine):
    """Langue de l'interface : français (textes d'origine), breton (repli sur le français pour ce qui n'est
    pas encore traduit), anglais pour toutes les autres langues. Renvoie (traduction, code de langue)."""
    code = "fr"
    for var in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
        v = os.environ.get(var, "")
        if v:
            code = v.split(":")[0].split(".")[0].split("@")[0].split("_")[0] or "fr"
            break
    if code in ("C", "POSIX"):
        code = "fr"
    if code == "fr":
        return _Francais(), code
    # KEMMOS_LOCALE : dossier des traductions pour les essais depuis les sources
    t = gettext.translation(domaine, os.environ.get("KEMMOS_LOCALE", "/usr/share/locale"),
                            languages=["br" if code == "br" else "en"], fallback=True)
    t.add_fallback(_Francais())
    return t, code


_trad, LANGUE = _traduction("kemmos-style")
_, ngettext = _trad.gettext, _trad.ngettext

APP_ID = "org.kemmos.Style"
FONDS = "/usr/share/wallpapers/kemmos/contents/images"
CONF = os.path.join(GLib.get_user_config_dir(), "kemmos")
FF_SYSTEME = "/etc/xdg/fastfetch/config.jsonc"
FF_PERSO = os.path.join(GLib.get_user_config_dir(), "fastfetch", "config.jsonc")
FF_OFF = os.path.join(CONF, "fastfetch-off")                    # témoin lu par ~/.bashrc
FF_MARQUE = "// Généré par KemmOS Style"
BIENVENUE_VUE = os.path.join(CONF, "bienvenue-vue")             # témoin de kemmos-bienvenue
RAPPEL = os.path.join(GLib.get_user_state_dir(), "kemmos", "rappel-sauvegarde")  # témoin du Centre
# Mode grand confort (1.6.0) : réglages d'avant gardés ici, remis quand on l'arrête
GRAND_CONFORT = os.path.join(CONF, "grand-confort.json")
# (schéma, clé, valeur du mode grand confort)
GRAND_CONFORT_REGLAGES = [
    ("org.gnome.desktop.interface", "text-scaling-factor", 1.25),     # textes plus grands
    ("org.gnome.desktop.a11y.interface", "high-contrast", True),       # contraste élevé
    ("org.gnome.desktop.interface", "cursor-size", 48),                # grand pointeur
    ("org.gnome.desktop.interface", "locate-pointer", True),           # Ctrl : montre où est le pointeur
    ("org.gnome.desktop.interface", "enable-animations", False),       # pas d'animations
    ("org.gnome.desktop.interface", "enable-hot-corners", False),      # pas de vue d'ensemble surprise (coin)
    ("org.gnome.desktop.peripherals.mouse", "double-click", 600),      # double-clic moins pressé
    ("org.gnome.shell.extensions.dash-to-dock", "dash-max-icon-size", 64),   # grandes icônes du dock
]
BASHRC = os.path.expanduser("~/.bashrc")
PTYXIS_PROFIL = "/org/gnome/Ptyxis/Profiles/ee48406ce2334f8b911f10bd65f86145/"
# ligne d'origine du bloc fastfetch de /etc/skel/.bashrc (config.sh jusqu'au build 81)
BASH_ANCIEN = 'if [[ $- == *i* ]] && [ "$TERM" != linux ] && command -v fastfetch >/dev/null; then'
BASH_NOUVEAU = ('if [[ $- == *i* ]] && [ "$TERM" != linux ] && command -v fastfetch >/dev/null '
                '&& [ ! -e "${XDG_CONFIG_HOME:-$HOME/.config}/kemmos/fastfetch-off" ]; then')

ACCENTS = [("blue", _("Bleu")), ("teal", _("Sarcelle")), ("green", _("Vert")), ("yellow", _("Jaune")),
           ("orange", _("Orange")), ("red", _("Rouge")), ("pink", _("Rose")), ("purple", _("Violet")), ("slate", _("Ardoise"))]
SCHEMES = [("default", _("Par défaut (clair)")), ("prefer-dark", _("Sombre")), ("prefer-light", _("Clair"))]
POSITIONS = [("BOTTOM", _("En bas")), ("LEFT", _("À gauche")), ("RIGHT", _("À droite")), ("TOP", _("En haut"))]
LOGOS = [("kemmos", _("KemmOS (caméléon)")), ("kemmos-couleur", _("KemmOS (image en couleurs)")),
         ("suse", _("Caméléon SUSE")), ("opensuse", _("Caméléon openSUSE")), ("none", _("Aucun logo"))]
# logo « image en couleurs » (octants Unicode 24 bits) : logo de la config système jusqu'à la 1.3.0
FF_LOGO_COULEUR = {"type": "file-raw", "source": "/usr/share/kemmos/fastfetch-logo.txt", "padding": {"top": 2, "left": 2}}
# icônes KemmOS des applis du dock : thème « KemmOS-<thème de base> » = dossier kemmos-apps + Inherits=<base>
# (image KemmOS depuis le build 82 : KemmOS-Newaita-reborn-mint ; autres bases : thème créé dans ~/.local)
ICONES_DOCK = "/usr/share/icons/KemmOS-Newaita-reborn-mint/kemmos-apps"
PREFIXE = "KemmOS-"
# lignes de la fiche fastfetch (type du module → libellé)
MODULES = [("os", _("Système")), ("kernel", _("Noyau")), ("uptime", _("Activité")), ("shell", "Shell"),
           ("packages", _("Paquets")), ("display", _("Écran")), ("de", _("Bureau")), ("terminal", _("Terminal")),
           ("host", _("Machine")), ("cpu", _("Processeur")), ("gpu", _("Carte graphique")), ("memory", _("Mémoire")),
           ("swap", "Swap"), ("disk", _("Disque")), ("localip", _("Adresse IP")), ("battery", _("Batterie")),
           ("poweradapter", _("Secteur"))]


def reglages(schema, chemin=None):
    """Gio.Settings ou None si le schéma n'est pas installé (extension absente)."""
    source = Gio.SettingsSchemaSource.get_default()
    if source is None or source.lookup(schema, True) is None:
        return None
    return Gio.Settings.new_with_path(schema, chemin) if chemin else Gio.Settings.new(schema)


def a_cle(s, cle):
    return s is not None and s.props.settings_schema.has_key(cle)


def reinit(s, *cles):
    for c in cles:
        if a_cle(s, c):
            s.reset(c)


def ecrire(chemin, texte):
    os.makedirs(os.path.dirname(chemin), exist_ok=True)
    tmp = chemin + ".tmp"
    with open(tmp, "w") as f:
        f.write(texte)
    os.replace(tmp, chemin)


def supprimer(chemin):
    try:
        os.remove(chemin)
    except FileNotFoundError:
        pass


def lire(chemin, defaut=""):
    try:
        with open(chemin) as f:
            return f.read()
    except OSError:
        return defaut


def jsonc(texte):
    """JSON avec commentaires « // » en début de ligne (format des configs fastfetch de KemmOS)."""
    return json.loads("\n".join(l for l in texte.splitlines() if not l.lstrip().startswith("//")))


def themes_icones():
    noms = set()
    for base in (os.path.expanduser("~/.local/share/icons"), os.path.expanduser("~/.icons"), "/usr/share/icons"):
        for index in glob.glob(os.path.join(base, "*", "index.theme")):
            # thème d'icônes = clé Directories ; les thèmes de curseurs seuls n'en ont pas
            texte = lire(index)
            if re.search(r"^Directories\s*=\s*\S", texte, re.M) and not re.search(r"^Hidden\s*=\s*true", texte, re.M):
                noms.add(os.path.basename(os.path.dirname(index)))
    noms.discard("hicolor")
    noms.discard("default")
    return sorted((n for n in noms if not n.startswith(PREFIXE)), key=str.lower)


def theme_dock(base):
    """Nom du thème « icônes KemmOS du dock + base », créé dans ~/.local/share/icons s'il n'existe pas."""
    nom = PREFIXE + base
    if os.path.isfile(os.path.join("/usr/share/icons", nom, "index.theme")):
        return nom
    d = os.path.join(GLib.get_user_data_dir(), "icons", nom)
    os.makedirs(d, exist_ok=True)
    # lien refait s'il ne mène pas aux icônes de l'image (ex. thème migré de GeekOS : il visait
    # /usr/share/icons/GeekOS-Newaita-reborn-mint/geekos-apps, supprimé → plus aucune icône KemmOS)
    lien = os.path.join(d, "kemmos-apps")
    if not (os.path.islink(lien) and os.readlink(lien) == ICONES_DOCK):
        if os.path.isdir(lien) and not os.path.islink(lien):
            shutil.rmtree(lien)
        elif os.path.lexists(lien):
            os.remove(lien)
        os.symlink(ICONES_DOCK, lien)
    # un cache périmé masquerait les icônes du lien
    if os.path.exists(os.path.join(d, "icon-theme.cache")):
        os.remove(os.path.join(d, "icon-theme.cache"))
    ecrire(os.path.join(d, "index.theme"),
           f"[Icon Theme]\nName=KemmOS ({base} + icônes du dock)\nComment=Créé par KemmOS Style\n"
           f"Inherits={base},Adwaita,hicolor\nDirectories=kemmos-apps\n\n"
           "[kemmos-apps]\nContext=Applications\nSize=128\nMinSize=16\nMaxSize=512\nType=Scalable\n")
    return nom


# Icônes et dossiers sur le bureau (1.5.0) : extension Gtk4 Desktop Icons NG livrée par ce paquet
DING = "gtk4-ding@smedius.gitlab.com"


def extensions():
    """(uuid, nom, description) des extensions installées, système et utilisateur."""
    res = {}
    for base in ("/usr/share/gnome-shell/extensions",
                 os.path.join(GLib.get_user_data_dir(), "gnome-shell", "extensions")):
        for meta in glob.glob(os.path.join(base, "*", "metadata.json")):
            try:
                with open(meta) as f:
                    m = json.load(f)
                res[m["uuid"]] = (m["uuid"], m.get("name", m["uuid"]), m.get("description", "").split("\n")[0])
            except (OSError, ValueError, KeyError):
                continue
    return sorted(res.values(), key=lambda e: e[1].lower())


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, app):
        super().__init__(application=app, title="KemmOS Style", default_width=760, default_height=760)
        self.interface = reglages("org.gnome.desktop.interface")
        self.fond = reglages("org.gnome.desktop.background")
        self.verrou = reglages("org.gnome.desktop.screensaver")
        self.wm = reglages("org.gnome.desktop.wm.preferences")
        self.shell = reglages("org.gnome.shell")
        self.dock = reglages("org.gnome.shell.extensions.dash-to-dock")
        self.barre = reglages("com.ftpix.transparentbar")
        self.ptyxis = reglages("org.gnome.Ptyxis")
        self.profil = reglages("org.gnome.Ptyxis.Profile", PTYXIS_PROFIL)
        self.maj = False   # vrai pendant qu'on recharge les widgets (pas d'écriture)
        self.reparer_icones_dock()
        self.en_masse = False   # « Tout remettre » : un seul message à la fin

        self.toasts = Adw.ToastOverlay()
        vue = Adw.ToolbarView()
        entete = Adw.HeaderBar()
        self.pile = Adw.ViewStack()
        entete.set_title_widget(Adw.ViewSwitcher(stack=self.pile, policy=Adw.ViewSwitcherPolicy.WIDE))
        menu = Gio.Menu()
        menu.append(_("Tout remettre comme KemmOS"), "win.tout")
        menu.append(_("À propos"), "win.apropos")
        entete.pack_end(Gtk.MenuButton(icon_name="open-menu-symbolic", menu_model=menu, tooltip_text=_("Menu")))
        for nom, rappel in (("tout", self.demander_tout), ("apropos", self.apropos)):
            a = Gio.SimpleAction.new(nom, None)
            a.connect("activate", lambda _a, _p, r=rappel: r())
            self.add_action(a)
        vue.add_top_bar(entete)
        vue.set_content(self.pile)
        self.toasts.set_child(vue)
        self.set_content(self.toasts)

        self.pages = {}
        for nom, titre, icone, construire in (
                ("apparence", _("Apparence"), "applications-graphics-symbolic", self.page_apparence),
                ("bureau", _("Bureau"), "user-desktop-symbolic", self.page_bureau),
                ("terminal", _("Terminal"), "utilities-terminal-symbolic", self.page_terminal),
                ("confort", _("Confort"), "emblem-favorite-symbolic", self.page_confort)):
            page = Adw.PreferencesPage()
            self.pile.add_titled_with_icon(page, nom, titre, icone)
            self.pages[nom] = (page, construire)
            self.construire(nom)

    # ---------- utilitaires ----------

    def construire(self, nom):
        page, fabrique = self.pages[nom]
        for g in getattr(page, "_groupes", []):
            page.remove(g)
        page._groupes = []
        self.maj = True
        for g in fabrique():
            page.add(g)
            page._groupes.append(g)
        self.maj = False

    def apres(self, page, texte):
        if not self.en_masse:
            self.construire(page)
            self.toast(texte)

    def toast(self, texte):
        self.toasts.add_toast(Adw.Toast(title=texte, timeout=3))

    def groupe(self, titre, description=None, reinit_rappel=None):
        g = Adw.PreferencesGroup(title=titre, description=description)
        if reinit_rappel:
            b = Gtk.Button(label=_("Réglages KemmOS"), valign=Gtk.Align.CENTER,
                           tooltip_text=_("Revenir aux réglages d'origine de KemmOS pour cette section"))
            b.add_css_class("flat")
            b.connect("clicked", lambda _b: reinit_rappel())
            g.set_header_suffix(b)
        return g

    def interrupteur(self, titre, sous_titre, actif, rappel, icone=None):
        r = Adw.SwitchRow(title=titre, subtitle=sous_titre or "")
        if icone:
            r.add_prefix(Gtk.Image(icon_name=icone))
        r.set_active(actif)
        r.connect("notify::active", lambda s, _p: None if self.maj else rappel(s.get_active()))
        return r

    def choix(self, titre, options, actuel, rappel, sous_titre=None):
        r = Adw.ComboRow(title=titre, subtitle=sous_titre or "")
        r.set_model(Gtk.StringList.new([lib for _v, lib in options]))
        valeurs = [v for v, _lib in options]
        r.set_selected(valeurs.index(actuel) if actuel in valeurs else Gtk.INVALID_LIST_POSITION)
        r.connect("notify::selected", lambda c, _p: None if self.maj or c.get_selected() >= len(valeurs)
                  else rappel(valeurs[c.get_selected()]))
        return r

    def curseur(self, titre, sous_titre, mini, maxi, pas, valeur, rappel):
        r = Adw.SpinRow.new_with_range(mini, maxi, pas)
        r.set_title(titre)
        r.set_subtitle(sous_titre or "")
        r.set_value(valeur)
        r.connect("notify::value", lambda s, _p: None if self.maj else rappel(s.get_value()))
        return r

    # ---------- Apparence ----------

    def page_apparence(self):
        res = []
        g = self.groupe(_("Fond d'écran"), _("Utilisé aussi pour l'écran de verrouillage."), self.reinit_fond)
        grille = Gtk.FlowBox(selection_mode=Gtk.SelectionMode.NONE, max_children_per_line=4,
                             min_children_per_line=4, row_spacing=4, column_spacing=4, homogeneous=True)
        actuel = self.fond.get_string("picture-uri") if self.fond else ""
        fonds = sorted(glob.glob(os.path.join(FONDS, "*.jp*g"))) + sorted(glob.glob(os.path.join(FONDS, "*.png")))
        for i, chemin in enumerate(fonds, 1):
            grille.append(self.vignette(chemin, Gio.File.new_for_path(chemin).get_uri() == actuel, i))
        # image personnelle en cours : affichée en plus, cochée
        chemin_actuel = Gio.File.new_for_uri(actuel).get_path() if actuel.startswith("file://") else None
        if chemin_actuel and chemin_actuel not in fonds and os.path.exists(chemin_actuel):
            grille.append(self.vignette(chemin_actuel, True, None))
        g.add(grille)
        perso = Adw.ActionRow(title=_("Image personnelle…"), subtitle=_("Choisir une image sur l'ordinateur"),
                              activatable=True)
        perso.add_prefix(Gtk.Image(icon_name="folder-pictures-symbolic"))
        perso.connect("activated", lambda _r: self.choisir_image())
        g.add(perso)
        res.append(g)

        g = self.groupe(_("Style"), None, self.reinit_style)
        if a_cle(self.interface, "color-scheme"):
            g.add(self.choix(_("Thème"), SCHEMES, self.interface.get_string("color-scheme"),
                             lambda v: self.interface.set_string("color-scheme", v)))
        if a_cle(self.interface, "accent-color"):
            g.add(self.choix(_("Couleur d'accent"), ACCENTS, self.interface.get_string("accent-color"),
                             lambda v: self.interface.set_string("accent-color", v)))
        themes = themes_icones()
        if self.interface and themes:
            base, dock = self.icones_actuelles()
            g.add(self.choix(_("Icônes"), [(t, t) for t in themes], base,
                             lambda v: self.appliquer_icones(v, self.icones_actuelles()[1]),
                             _("KemmOS : Newaita-reborn-mint")))
            if os.path.isdir(ICONES_DOCK):
                g.add(self.interrupteur(_("Icônes KemmOS du dock"),
                                        _("Terminal, Fichiers, navigateurs… dessinés pour KemmOS, sur le thème "
                                          "choisi"),
                                        dock, lambda v: self.appliquer_icones(self.icones_actuelles()[0], v)))
        if self.wm:
            g.add(self.interrupteur(_("Boutons réduire et agrandir"), _("Sinon seulement le bouton fermer (GNOME)"),
                                    "minimize" in self.wm.get_string("button-layout"),
                                    lambda v: self.wm.set_string("button-layout", "appmenu:minimize,maximize,close"
                                                                  if v else "appmenu:close")))
        res.append(g)
        return res

    def icones_actuelles(self):
        t = self.interface.get_string("icon-theme")
        return (t[len(PREFIXE):], True) if t.startswith(PREFIXE) else (t, False)

    def reparer_icones_dock(self):
        """Thème KemmOS-<base> de ~/.local actif mais lien vers les icônes du dock cassé (PC migré de GeekOS) :
        le refaire, puis repasser par le thème de base pour que GNOME Shell recharge les icônes."""
        if not self.interface or not os.path.isdir(ICONES_DOCK):
            return
        base, dock = self.icones_actuelles()
        lien = os.path.join(GLib.get_user_data_dir(), "icons", PREFIXE + base, "kemmos-apps")
        if not dock or not os.path.lexists(lien) or os.path.realpath(lien) == os.path.realpath(ICONES_DOCK):
            return
        try:
            nom = theme_dock(base)
        except OSError as e:
            print("kemmos-style: réparation du thème", e, file=sys.stderr)
            return
        self.interface.set_string("icon-theme", base)
        GLib.timeout_add(500, lambda: self.interface.set_string("icon-theme", nom) and False)

    def appliquer_icones(self, base, dock):
        try:
            nom = theme_dock(base) if dock and os.path.isdir(ICONES_DOCK) else base
        except OSError as e:
            self.toast(_("Impossible de créer le thème : {erreur}").format(erreur=e.strerror))
            return
        self.interface.set_string("icon-theme", nom)

    def vignette(self, chemin, actif, numero):
        b = Gtk.Button(tooltip_text=os.path.basename(chemin))
        b.add_css_class("flat")
        boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4)
        # miniature réduite au chargement : Gtk.Picture prendrait sinon la taille de l'image (1920 px et plus)
        try:
            mini = GdkPixbuf.Pixbuf.new_from_file_at_scale(chemin, 160, 90, False)
            ok, png = mini.save_to_bufferv("png", [], [])
            img = Gtk.Picture.new_for_paintable(Gdk.Texture.new_from_bytes(GLib.Bytes.new(png)))
        except GLib.Error:
            img = Gtk.Picture()
        img.set_size_request(160, 90)
        boite.append(img)
        legende = Gtk.Label(label=_("✔ Actuel") if actif else (_("Fond {n}").format(n=numero) if numero
                                                               else _("Image perso")))
        legende.add_css_class("caption")
        if actif:
            legende.add_css_class("success")
            legende.add_css_class("heading")
        boite.append(legende)
        b.set_child(boite)
        b.connect("clicked", lambda _b: self.appliquer_fond(Gio.File.new_for_path(chemin).get_uri()))
        return b

    def appliquer_fond(self, uri):
        for s, cles in ((self.fond, ("picture-uri", "picture-uri-dark")), (self.verrou, ("picture-uri",))):
            for c in cles:
                if a_cle(s, c):
                    s.set_string(c, uri)
        self.apres("apparence", _("Fond d'écran appliqué"))

    def choisir_image(self):
        filtre = Gtk.FileFilter(name=_("Images"))
        filtre.add_mime_type("image/*")
        filtres = Gio.ListStore.new(Gtk.FileFilter)
        filtres.append(filtre)
        dlg = Gtk.FileDialog(title=_("Choisir un fond d'écran"), filters=filtres)

        def fini(d, res):
            try:
                f = d.open_finish(res)
            except GLib.Error:
                return
            # copie dans ~/.local/share/backgrounds : le fond reste si l'original est déplacé (clé USB…)
            dest_dir = os.path.join(GLib.get_user_data_dir(), "backgrounds")
            os.makedirs(dest_dir, exist_ok=True)
            dest = os.path.join(dest_dir, os.path.basename(f.get_path()))
            if os.path.abspath(f.get_path()) != os.path.abspath(dest):
                shutil.copy2(f.get_path(), dest)
            self.appliquer_fond(Gio.File.new_for_path(dest).get_uri())
        dlg.open(self, None, fini)

    def reinit_fond(self):
        reinit(self.fond, "picture-uri", "picture-uri-dark", "picture-options", "primary-color", "secondary-color")
        reinit(self.verrou, "picture-uri", "picture-options", "primary-color", "secondary-color")
        self.apres("apparence", _("Fond d'écran KemmOS rétabli"))

    def reinit_style(self):
        reinit(self.interface, "color-scheme", "accent-color", "icon-theme")
        reinit(self.wm, "button-layout")
        self.apres("apparence", _("Style KemmOS rétabli"))

    # ---------- Bureau ----------

    def page_bureau(self):
        res = []
        if self.shell and DING in {u for u, _n, _d in extensions()}:
            g = self.groupe(_("Bureau"), _("Le fond d'écran peut accueillir des icônes, comme sous Windows : "
                                           "dossier personnel, corbeille, clés USB, et tout ce que vous rangez dans "
                                           "le dossier « Bureau »."))
            g.add(self.interrupteur(_("Icônes sur le bureau"),
                                    _("Clic droit sur le bureau : nouveau dossier, coller, réglages (taille des "
                                      "icônes…)"),
                                    DING in self.shell.get_strv("enabled-extensions"),
                                    lambda v: self.regler_extension(DING, v), "user-desktop-symbolic"))
            res.append(g)
        if self.dock:
            g = self.groupe(_("Dock"), None, self.reinit_dock)
            g.add(self.choix(_("Position"), POSITIONS, self.dock.get_string("dock-position"),
                             lambda v: self.dock.set_string("dock-position", v)))
            g.add(self.curseur(_("Taille des icônes"), _("en pixels"), 16, 128, 4,
                               self.dock.get_int("dash-max-icon-size"),
                               lambda v: self.dock.set_int("dash-max-icon-size", int(v))))
            g.add(self.curseur(_("Opacité du fond"), _("en % (KemmOS : 9)"), 0, 100, 1,
                               round(self.dock.get_double("background-opacity") * 100),
                               self.regler_opacite_dock))
            g.add(self.interrupteur(_("Toujours visible"), _("Sinon le dock s'efface devant les fenêtres"),
                                    self.dock.get_boolean("dock-fixed"),
                                    lambda v: self.dock.set_boolean("dock-fixed", v)))
            g.add(self.interrupteur(_("Toute la largeur"), _("Le dock occupe tout le bord de l'écran"),
                                    self.dock.get_boolean("extend-height"),
                                    lambda v: self.dock.set_boolean("extend-height", v)))
            res.append(g)
        if self.barre:
            g = self.groupe(_("Barre du haut"), None, self.reinit_barre)
            g.add(self.curseur(_("Opacité"), _("en % (KemmOS : 9)"), 0, 100, 1, self.barre.get_int("transparency"),
                               lambda v: self.barre.set_int("transparency", int(v))))
            res.append(g)
        if self.shell:
            g = self.groupe(_("Extensions"), _("Ajouts à GNOME installés sur ce système."), self.reinit_extensions)
            actives = self.shell.get_strv("enabled-extensions")
            for uuid, nom, desc in extensions():
                if uuid == DING:
                    continue   # interrupteur dédié, groupe « Bureau » ci-dessus
                g.add(self.interrupteur(GLib.markup_escape_text(nom), GLib.markup_escape_text(desc),
                                        uuid in actives, lambda v, u=uuid: self.regler_extension(u, v)))
            res.append(g)
        return res

    def regler_opacite_dock(self, v):
        # l'opacité n'est appliquée qu'en mode FIXED (Dash to Dock)
        self.dock.set_string("transparency-mode", "FIXED")
        self.dock.set_double("background-opacity", v / 100)

    def regler_extension(self, uuid, actif):
        actives = [u for u in self.shell.get_strv("enabled-extensions") if u != uuid]
        if actif:
            actives.append(uuid)
        self.shell.set_strv("enabled-extensions", actives)
        if a_cle(self.shell, "disabled-extensions"):
            self.shell.set_strv("disabled-extensions",
                                [u for u in self.shell.get_strv("disabled-extensions") if u != uuid]
                                + ([] if actif else [uuid]))
        if actif and a_cle(self.shell, "disable-user-extensions") and self.shell.get_boolean("disable-user-extensions"):
            self.shell.set_boolean("disable-user-extensions", False)

    def reinit_dock(self):
        reinit(self.dock, "dock-position", "dash-max-icon-size", "background-opacity", "transparency-mode",
               "dock-fixed", "extend-height")
        self.apres("bureau", _("Dock KemmOS rétabli"))

    def reinit_barre(self):
        reinit(self.barre, "transparency")
        self.apres("bureau", _("Barre du haut KemmOS rétablie"))

    def reinit_extensions(self):
        reinit(self.shell, "enabled-extensions", "disabled-extensions", "disable-user-extensions")
        self.apres("bureau", _("Extensions KemmOS rétablies"))

    # ---------- Terminal ----------

    def page_terminal(self):
        res = []
        conf = self.conf_fastfetch()
        g = self.groupe(_("Fiche système (fastfetch)"), _("Affichée à l'ouverture de chaque terminal."),
                        self.reinit_fastfetch)
        g.add(self.interrupteur(_("Afficher la fiche système"), None, not os.path.exists(FF_OFF),
                                self.regler_fastfetch_actif, "utilities-terminal-symbolic"))
        g.add(self.choix(_("Logo"), LOGOS, self.logo_actuel(conf), self.regler_logo))
        essai = Adw.ActionRow(title=_("Essayer"), subtitle=_("Ouvre un terminal avec la fiche actuelle"),
                              activatable=True)
        essai.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
        essai.connect("activated", lambda _r: self.essayer())
        g.add(essai)
        res.append(g)

        g = self.groupe(_("Lignes de la fiche"), None)
        presents = {self.type_module(m) for m in conf.get("modules", [])}
        for typ, lib in MODULES:
            g.add(self.interrupteur(lib, None, typ in presents, lambda v, t=typ: self.regler_module(t, v)))
        res.append(g)

        g = self.groupe(_("Fenêtre du terminal (Ptyxis)"), None, self.reinit_ptyxis)
        if a_cle(self.profil, "opacity"):
            g.add(self.curseur(_("Opacité du fond"), _("en % (KemmOS : 77)"), 20, 100, 1,
                               round(self.profil.get_double("opacity") * 100),
                               lambda v: self.profil.set_double("opacity", v / 100)))
        if a_cle(self.ptyxis, "default-columns"):
            g.add(self.curseur(_("Largeur"), _("en colonnes (KemmOS : 130)"), 40, 300, 1,
                               self.ptyxis.get_uint("default-columns"),
                               lambda v: self.ptyxis.set_uint("default-columns", int(v))))
            g.add(self.curseur(_("Hauteur"), _("en lignes (KemmOS : 32)"), 10, 120, 1,
                               self.ptyxis.get_uint("default-rows"),
                               lambda v: self.ptyxis.set_uint("default-rows", int(v))))
        res.append(g)
        return res

    @staticmethod
    def type_module(m):
        return m if isinstance(m, str) else m.get("type", "")

    def conf_fastfetch(self):
        for chemin in (FF_PERSO, FF_SYSTEME):
            try:
                return jsonc(lire(chemin))
            except ValueError:
                continue
        return {"modules": [t for t, _l in MODULES]}

    def logo_actuel(self, conf):
        logo = conf.get("logo", {})
        if isinstance(logo, str):
            return logo
        if logo.get("type") == "none":
            return "none"
        if logo.get("type") == "file-raw":
            return "kemmos-couleur"
        if logo.get("type") == "file":
            return "kemmos"
        return logo.get("source", "kemmos")

    def sauver_fastfetch(self, modifier):
        perso = lire(FF_PERSO)
        if perso and FF_MARQUE not in perso:
            # config personnelle écrite à la main : on la garde de côté avant de la remplacer
            shutil.copy2(FF_PERSO, FF_PERSO + ".avant-kemmos-style")
            self.toast(_("Ancienne config gardée : config.jsonc.avant-kemmos-style"))
        try:
            base = jsonc(perso) if perso and FF_MARQUE in perso else jsonc(lire(FF_SYSTEME))
        except ValueError:
            base = self.conf_fastfetch()
        modifier(base)
        ecrire(FF_PERSO, FF_MARQUE + " (supprimer ce fichier = réglages KemmOS)\n"
               + json.dumps(base, ensure_ascii=False, indent=4) + "\n")

    def regler_logo(self, v):
        def m(c):
            if v == "kemmos":
                c["logo"] = jsonc(lire(FF_SYSTEME)).get("logo", {})
            elif v == "kemmos-couleur":
                c["logo"] = dict(FF_LOGO_COULEUR)
            elif v == "none":
                c["logo"] = {"type": "none"}
            else:
                c["logo"] = {"type": "builtin", "source": v, "padding": {"top": 1, "left": 2}}
        self.sauver_fastfetch(m)

    def regler_module(self, typ, actif):
        systeme = [x for x in jsonc(lire(FF_SYSTEME)).get("modules", [])]

        def m(c):
            mods = c.get("modules", [])
            if actif:
                if typ in {self.type_module(x) for x in mods}:
                    return
                # reprend la ligne KemmOS (libellé, format) et la place dans l'ordre d'origine
                modele = next((x for x in systeme if self.type_module(x) == typ), typ)
                ordre = [self.type_module(x) for x in systeme]
                rang = ordre.index(typ) if typ in ordre else len(ordre)
                pos = next((i for i, x in enumerate(mods)
                            if self.type_module(x) in ordre and ordre.index(self.type_module(x)) > rang), len(mods))
                mods.insert(pos, modele)
            else:
                mods = [x for x in mods if self.type_module(x) != typ]
            c["modules"] = mods
        self.sauver_fastfetch(m)

    def regler_fastfetch_actif(self, actif):
        if actif:
            supprimer(FF_OFF)
            self.toast(_("Fiche système activée"))
            return
        ecrire(FF_OFF, "")
        self.adapter_bashrc()

    def adapter_bashrc(self):
        """~/.bashrc créé avant KemmOS Style : sa ligne fastfetch ne connaît pas le témoin → mise à jour."""
        texte = lire(BASHRC)
        if BASH_NOUVEAU in texte or "fastfetch-off" in texte:
            self.toast(_("Fiche système désactivée"))
        elif BASH_ANCIEN in texte:
            shutil.copy2(BASHRC, BASHRC + ".avant-kemmos-style")
            ecrire(BASHRC, texte.replace(BASH_ANCIEN, BASH_NOUVEAU))
            self.toast(_("Fiche système désactivée (~/.bashrc mis à jour, copie .avant-kemmos-style)"))
        elif "fastfetch" in texte:
            self.toast(_("~/.bashrc personnalisé : retirez-y la ligne « fastfetch » vous-même"))
        else:
            self.toast(_("Fiche système désactivée"))

    def essayer(self):
        for cmd in (["ptyxis", "--new-window"], ["kgx"], ["gnome-terminal"]):
            if shutil.which(cmd[0]):
                subprocess.Popen(cmd, start_new_session=True)
                return
        self.toast(_("Aucun terminal trouvé"))

    def reinit_fastfetch(self):
        supprimer(FF_OFF)
        if FF_MARQUE in lire(FF_PERSO):
            supprimer(FF_PERSO)
        self.apres("terminal", _("Fiche système KemmOS rétablie"))

    def reinit_ptyxis(self):
        reinit(self.profil, "opacity", "palette")
        reinit(self.ptyxis, "default-columns", "default-rows")
        self.apres("terminal", _("Terminal KemmOS rétabli"))

    # ---------- Confort ----------

    def page_confort(self):
        gc = self.groupe(_("Grand confort"), _("Pour mieux voir et cliquer plus facilement : textes plus grands, "
                                               "contraste élevé, grand pointeur, grandes icônes du dock, pas "
                                               "d'animations ni de coin qui ouvre la vue d'ensemble, double-clic "
                                               "moins pressé. Arrêter le mode remet vos réglages d'avant."))
        gc.add(self.interrupteur(_("Mode grand confort"), _("Touche Ctrl : montre où est le pointeur"),
                                 os.path.exists(GRAND_CONFORT), self.regler_grand_confort,
                                 "preferences-desktop-accessibility-symbolic"))
        g = self.groupe(_("À l'ouverture de session"), None, self.reinit_confort)
        g.add(self.interrupteur(_("Fenêtre de bienvenue"), _("Liens utiles et présentation de KemmOS"),
                                not os.path.exists(BIENVENUE_VUE), self.regler_bienvenue, "kemmos"))
        if os.path.exists("/usr/libexec/kemmos-centre/rappel-sauvegarde"):
            g.add(self.interrupteur(_("Rappel de sauvegarde"),
                                    _("Au plus une fois par semaine si aucune sauvegarde récente"),
                                    lire(RAPPEL).strip() != "jamais", self.regler_rappel, "alarm-symbolic"))
        return [gc, g]

    def regler_grand_confort(self, actif):
        if actif:
            avant = {}
            for schema, cle, valeur in GRAND_CONFORT_REGLAGES:
                r = reglages(schema)
                if not a_cle(r, cle):
                    continue   # ex. dock absent
                # valeur d'avant ; None = valeur par défaut (on remettra le défaut, pas une copie figée)
                avant[f"{schema} {cle}"] = r.get_user_value(cle).unpack() if r.get_user_value(cle) else None
                r.set_value(cle, GLib.Variant(r.get_value(cle).get_type_string(), valeur))
            ecrire(GRAND_CONFORT, json.dumps(avant, indent=1))
            self.construire("bureau")   # taille des icônes du dock
            self.toast(_("Mode grand confort activé"))
        else:
            try:
                avant = json.loads(lire(GRAND_CONFORT, "{}"))
            except ValueError:
                avant = {}
            for schema, cle, _valeur in GRAND_CONFORT_REGLAGES:
                r = reglages(schema)
                if not a_cle(r, cle):
                    continue
                v = avant.get(f"{schema} {cle}")
                if v is None or self.en_masse:   # « Tout remettre » : réglages KemmOS, pas ceux d'avant
                    r.reset(cle)
                else:
                    r.set_value(cle, GLib.Variant(r.get_value(cle).get_type_string(), v))
            supprimer(GRAND_CONFORT)
            if not self.en_masse:
                self.construire("bureau")
                self.toast(_("Mode grand confort arrêté : réglages d'avant remis"))

    def regler_bienvenue(self, actif):
        if actif:
            supprimer(BIENVENUE_VUE)
        else:
            ecrire(BIENVENUE_VUE, "")

    def regler_rappel(self, actif):
        ecrire(RAPPEL, "" if actif else "jamais\n")

    def reinit_confort(self):
        if os.path.exists(GRAND_CONFORT):
            self.regler_grand_confort(False)
        supprimer(BIENVENUE_VUE)
        ecrire(RAPPEL, "")
        self.apres("confort", _("Réglages de session KemmOS rétablis"))

    # ---------- tout ----------

    def demander_tout(self):
        d = Adw.AlertDialog(heading=_("Tout remettre comme KemmOS ?"),
                            body=_("Fond d'écran, style, dock, barre du haut, extensions, terminal, fastfetch, mode "
                                   "grand confort et fenêtre de bienvenue reprennent les réglages d'origine de KemmOS."))
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Tout remettre"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.DESTRUCTIVE)
        d.connect("response", lambda _d, r: self.tout() if r == "ok" else None)
        d.present(self)

    def tout(self):
        self.en_masse = True
        for f in (self.reinit_fond, self.reinit_style, self.reinit_dock, self.reinit_barre,
                  self.reinit_extensions, self.reinit_fastfetch, self.reinit_ptyxis, self.reinit_confort):
            try:
                f()
            except (GLib.Error, OSError) as e:
                print("kemmos-style:", f.__name__, e, file=sys.stderr)
        self.en_masse = False
        for nom in self.pages:
            self.construire(nom)
        self.toast(_("Réglages KemmOS rétablis"))

    def apropos(self):
        d = Adw.AboutDialog(application_name="KemmOS Style", application_icon="kemmos", version="1.6.0",
                            developer_name="KemmOS", license_type=Gtk.License.GPL_3_0,
                            website="https://nawre-tech.log.bzh/kemmos/",
                            comments=_("Personnaliser KemmOS à votre goût, et revenir aux réglages d'origine "
                                       "en un clic."))
        if _("translator-credits") != "translator-credits":
            d.set_translator_credits(_("translator-credits"))
        d.present(self)


class Appli(Adw.Application):
    def __init__(self):
        super().__init__(application_id=APP_ID, flags=Gio.ApplicationFlags.DEFAULT_FLAGS)

    def do_activate(self):
        (self.props.active_window or Fenetre(self)).present()


if __name__ == "__main__":
    sys.exit(Appli().run(sys.argv))
