#!/usr/bin/python3
# Centre KemmOS (build 79, 1.1.0 : section Matériel, rappel de sauvegarde ; 1.3.0 : logiciels à la carte ;
# 1.4.0 : guide hors ligne ; 1.5.0 : onglets Sécurité (pare-feu, MAC wifi aléatoire, antivirus ClamAV) et
# Réseau (adresse IP fixe, IP publique) ; 1.6.0 : onglet Système (profils Équilibré, Jeux, Sécurité) ; 1.7.0 :
# points de restauration dans l'onglet Système ; 1.7.1 : sous-groupes des Utilisateurs avancés ; 1.8.0 :
# assistant « Je viens de Windows » dans l'onglet Aide ; 1.9.0 : démarrage (système par défaut, Windows en
# double démarrage) dans l'onglet Système ; 1.10.0 : logithèque KemmOS-Apps ; 1.11.0 : disposition KemmOS 1.2
# pour les systèmes installés avant ; 1.12.0 : traduit en breton et en anglais ; 1.15.0 : recherche, mises à jour
# prudentes et retour automatique (onglet Système), caméra et micro (onglet Sécurité), température, usure du SSD,
# mémoire et sauvegarde vérifiée (tableau de bord), Tester mon ordinateur et coffre-fort des papiers ; 1.16.0 :
# Réinitialiser KemmOS et Préparer une clé USB KemmOS, onglet Système) : état du
# système en un coup d'œil, groupes de logiciels de l'installateur
# installables après coup, rapport de diagnostic. Tourne en utilisateur normal ; ce qui modifie le système
# passe par pkexec (/usr/libexec/kemmos-centre/*, actions polkit org.kemmos.centre.*).
import gettext
import json
import os
import re
import shutil
import ipaddress
import subprocess
import sys
import threading
import time
import unicodedata
import urllib.request

import gi
import yaml

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("Graphene", "1.0")
from gi.repository import Adw, Gio, GLib, GObject, Graphene, Gtk  # noqa: E402
try:   # GLib ≥ 2.86 : Gio.DesktopAppInfo déplacé dans GioUnix (l'ancien nom affiche un avertissement)
    gi.require_version("GioUnix", "2.0")
    from gi.repository.GioUnix import DesktopAppInfo  # noqa: E402
except (ValueError, ImportError):
    DesktopAppInfo = Gio.DesktopAppInfo


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-centre")
_, ngettext = _trad.gettext, _trad.ngettext

APP_ID = "org.kemmos.Centre"
GROUPES = "/usr/share/kemmos/groupes.yml"
AIDE_GROUPES = "/usr/libexec/kemmos-centre/groupes"
AIDE_PAREFEU = "/usr/libexec/kemmos-centre/parefeu"
AIDE_MAC = "/usr/libexec/kemmos-centre/mac"
AIDE_ANTIVIRUS = "/usr/libexec/kemmos-centre/antivirus"
AIDE_RESEAU = "/usr/libexec/kemmos-centre/reseau"
AIDE_PROFIL = "/usr/libexec/kemmos-centre/profil"
AIDE_INSTANTANES = "/usr/libexec/kemmos-centre/instantanes"
AIDE_INSTANTANES_LISTE = "/usr/libexec/kemmos-centre/instantanes-liste"   # lecture seule, sans mot de passe
AIDE_DEMARRAGE = "/usr/libexec/kemmos-centre/demarrage"
AIDE_DEMARRAGE_LISTE = "/usr/libexec/kemmos-centre/demarrage-liste"   # lecture seule, sans mot de passe
AIDE_GNOME_LOGICIELS = "/usr/libexec/kemmos-centre/gnome-logiciels"
AIDE_CAMERA = "/usr/libexec/kemmos-centre/camera"
AIDE_REINIT = "/usr/libexec/kemmos-centre/reinitialiser"
MICRO = "/usr/libexec/kemmos-centre/micro"                      # sans mot de passe (session de l'utilisateur)
VERIF_SAUVEGARDE = "/usr/libexec/kemmos-centre/verif-sauvegarde"
ETAT_VERIF = os.path.join(GLib.get_user_state_dir(), "kemmos", "sauvegarde-verifiee.json")
CAMERA_COUPEE = "/etc/modprobe.d/90-kemmos-camera.conf"
# KemmOS-Update 1.8.0 : mises à jour prudentes, retour automatique si le démarrage échoue
KEMMOS_UPDATE = "/usr/bin/kemmos-update"
PRUDENT = "/usr/share/kemmos-update/prudent.py"
ETAT_PRUDENT = "/var/lib/kemmos-update/prudent.json"
RETOUR_AUTO = "/usr/libexec/kemmos-update/retour-auto"
# Disposition KemmOS 1.2 (1.11.0) pour les systèmes installés avant : mêmes valeurs que l'image 1.2
# (root/usr/share/glib-2.0/schemas/30_kemmos-branding.gschema.override, root/etc/dconf/db/kemmos.d/10-dossiers),
# écrites dans les réglages de l'utilisateur (les valeurs par défaut du système sont celles de l'ancienne image).
DOCK_KEMMOS = ["org.kemmos.Centre.desktop", "org.kemmos.Apps.desktop"]
DOCK_ANCIEN = "org.gnome.Software.desktop"
DOSSIER_KEMMOS = ["org.kemmos.Centre.desktop", "org.kemmos.Apps.desktop", "org.kemmos.Style.desktop",
                  "org.kemmos.Windows.desktop", "org.kemmos.Guide.desktop"]
# dossiers en tête de la grille, dans cet ordre (dossier vide = ignoré par GNOME Shell)
ORDRE_DOSSIERS = ["kemmos-kemmos", "Game", "Utilities", "System", "kemmos-code", "kemmos-reseau", "YaST", "Pardus"]
TYPES_APPS = ["application/vnd.flatpak.ref", "x-scheme-handler/appstream"]   # .flatpakref, liens appstream://
DELAIS_MENU = (3, 5, 10, 30)   # mêmes valeurs que l'aide demarrage
MAX_INSTANTANES = 15   # points de restauration montrés (les plus récents)
MAC = "/etc/NetworkManager/conf.d/90-kemmos-mac.conf"   # présent = adresse MAC wifi aléatoire (voir mac)
CLAMSCAN = "/usr/bin/clamscan"
BASE_VIRUS = "/var/lib/clamav"
QUARANTAINE = "/var/lib/kemmos/quarantaine/index.json"   # écrit par l'aide antivirus, lisible par tous
# Interrupteurs du pare-feu (onglet Sécurité) : services firewalld, titre, précision, icône
SERVICES_PF = [
    (("samba", "samba-client"), _("Partage de fichiers (Samba)"),
     _("Voir les dossiers partagés des autres ordinateurs (Fichiers → Autres emplacements) et partager les vôtres "
       "(serveur Samba, groupe « Utilisateurs avancés »)"), "folder-remote-symbolic"),
    (("ssh",), _("Accès à distance (SSH)"),
     _("Se connecter à cet ordinateur depuis un autre en ligne de commande (serveur openssh à installer)"),
     "utilities-terminal-symbolic"),
    (("kdeconnect",), _("Téléphone (GSConnect / KDE Connect)"),
     _("Notifications, fichiers et presse-papiers partagés avec un téléphone Android"), "phone-symbolic"),
    (("syncthing",), "Syncthing", _("Synchronisation de dossiers entre vos appareils"), "emblem-synchronizing-symbolic"),
    (("rdp",), _("Bureau à distance (RDP)"), _("Prendre la main sur cet ordinateur depuis un autre (Paramètres → Système "
                                               "→ Bureau à distance)"), "preferences-desktop-remote-desktop-symbolic"),
    (("steam-streaming",), "Steam Remote Play", _("Jouer sur un autre appareil de la maison à des jeux lancés ici"),
     "input-gaming-symbolic"),
]
# Types de connexion NetworkManager montrés dans l'onglet Réseau : nom, icône
GENRES_NM = {"802-3-ethernet": (_("Câble"), "network-wired-symbolic"),
             "802-11-wireless": (_("Wifi"), "network-wireless-symbolic")}
SOCLE = "/usr/share/kemmos/socle-groupes.txt"   # éléments des groupes déjà dans l'image : jamais retirés
STATUT_MAJ = "/var/lib/kemmos-update/status.json"


def _charger_bilan():
    """Fonctions du bilan de santé (santé des disques), partagées avec le tableau de bord."""
    import importlib.machinery
    import importlib.util
    chemin = os.environ.get("KEMMOS_BILAN", "/usr/libexec/kemmos-centre/bilan-sante")
    try:
        chargeur = importlib.machinery.SourceFileLoader("bilan_sante", chemin)
        module = importlib.util.module_from_spec(importlib.util.spec_from_loader("bilan_sante", chargeur))
        chargeur.exec_module(module)
        return module
    except (OSError, ImportError, SyntaxError):
        return None


BILAN = _charger_bilan()
URL = "https://nawre-tech.log.bzh/kemmos/"
GUIDE = "/usr/share/kemmos/guide-kemmos.html"   # copie hors ligne du wiki du site (prepare.sh)
RAPPEL = os.path.join(GLib.get_user_state_dir(), "kemmos", "rappel-sauvegarde")  # voir rappel-sauvegarde
PCI = "/sys/bus/pci/devices"
PROGRES = re.compile(r"^\((\d+)/(\d+)\) ")

# Noms et descriptions en français (le fichier des groupes est en anglais, langue de l'installateur)
GROUPES_FR = {
    # Utilisateurs avancés : trois sous-groupes depuis la 1.7.1 (build 94), affichés chacun à part
    "Power users": (_("Utilisateurs avancés"), "", "applications-engineering-symbolic"),
    "Network and security": (_("Utilisateurs avancés : réseau et sécurité"),
                             _("Outils réseau et sécurité (Wireshark, nmap, Angry IP Scanner), Tor Browser, "
                               "FileZilla, Remmina, qBittorrent, antivirus, Lynis, Flatseal"),
                             "network-workgroup-symbolic"),
    "Development and AI": (_("Utilisateurs avancés : développement et IA"),
                           _("VSCodium, Spyder, git, Meld, compilateurs, Python, Rust, Go, Node.js, empaquetage "
                             "OBS/RPM, Ollama (modèles d'IA en local, téléchargés à part)"),
                           "applications-engineering-symbolic"),
    "Virtualization and containers": (_("Utilisateurs avancés : virtualisation et conteneurs"),
                                      _("Machines virtuelles (KVM, virt-manager), conteneurs (Podman, Distrobox)"),
                                      "computer-symbolic"),
    "Gaming": (_("Jeux"),
               _("Steam, Lutris, Wine, Protontricks, Bottles (logiciels Windows), Prism Launcher (Minecraft), "
                 "GameMode, MangoHud, Gamescope"), "input-gaming-symbolic"),
    "NVIDIA drivers (RTX)": (_("Pilote NVIDIA (RTX)"),
                             _("Pilote officiel NVIDIA (branche G06, module open signé, compatible "
                               "Secure Boot), bibliothèques 32 bits pour les jeux, nvidia-smi"),
                             "video-display-symbolic"),
}

# Nom affiché et précision pour chaque élément des groupes (sinon : le nom du paquet)
NOMS = {
    "nmap": ("Nmap", _("scanner de ports et de réseau")),
    "wireshark": ("Wireshark", _("analyse du trafic réseau")),
    "speedtest-cli": ("Speedtest", _("test de débit Internet en ligne de commande")),
    "bind-utils": (_("dig / nslookup"), _("requêtes DNS")),
    "traceroute": ("traceroute", _("chemin des paquets sur le réseau")),
    "mtr": ("mtr", _("traceroute et ping en continu")),
    "tcpdump": ("tcpdump", _("capture réseau en ligne de commande")),
    "whois": ("whois", _("propriétaire d'un domaine ou d'une adresse IP")),
    "torbrowser-launcher": ("Tor Browser", _("navigation anonyme (navigateur téléchargé au 1er lancement)")),
    "torbrowser-launcher-lang": (_("Tor Browser — traductions"), ""),
    "filezilla": ("FileZilla", _("client FTP/SFTP")),
    "remmina": ("Remmina", _("bureau à distance")),
    "remmina-plugin-rdp": (_("Remmina — module RDP"), _("bureaux Windows")),
    "remmina-plugin-vnc": (_("Remmina — module VNC"), ""),
    "qbittorrent": ("qBittorrent", _("téléchargement torrent")),
    "clamav": ("ClamAV", "antivirus"),
    "lynis": ("Lynis", _("audit de sécurité du système")),
    "flatseal": ("Flatseal", _("permissions des applications Flatpak")),
    "flatpak:org.angryip.ipscan": ("Angry IP Scanner", _("machines présentes sur le réseau")),
    "podman": ("Podman", "conteneurs"),
    "distrobox": ("Distrobox", _("autres distributions Linux en conteneur")),
    "qemu-kvm": ("QEMU/KVM", _("machines virtuelles")),
    "libvirt": ("libvirt", _("gestion des machines virtuelles")),
    "libvirt-daemon": (_("libvirt — service"), ""),
    "virt-manager": (_("Gestionnaire de machines virtuelles"), "virt-manager"),
    "bridge-utils": ("bridge-utils", _("ponts réseau pour les machines virtuelles")),
    "git": ("Git", _("gestion de versions")),
    "git-lfs": ("Git LFS", _("gros fichiers dans Git")),
    "gh": ("GitHub CLI", _("GitHub en ligne de commande")),
    "meld": ("Meld", _("comparaison et fusion de fichiers")),
    "gcc": ("GCC", _("compilateur C")),
    "gcc-c++": ("G++", _("compilateur C++")),
    "clang": ("Clang", _("compilateur C/C++ LLVM")),
    "make": ("Make", ""),
    "cmake": ("CMake", ""),
    "meson": ("Meson", ""),
    "ninja": ("Ninja", ""),
    "autoconf": ("Autoconf", ""),
    "automake": ("Automake", ""),
    "libtool": ("Libtool", ""),
    "pkgconf-pkg-config": ("pkg-config", ""),
    "gdb": ("GDB", _("débogueur")),
    "valgrind": ("Valgrind", _("fuites mémoire")),
    "ShellCheck": ("ShellCheck", _("vérification des scripts shell")),
    "jq": ("jq", _("JSON en ligne de commande")),
    "sqlite3": ("SQLite", _("base de données en ligne de commande")),
    "python3-pip": ("pip", _("paquets Python")),
    "python3-devel": (_("Python — fichiers de développement"), ""),
    "python3-virtualenv": ("virtualenv", _("environnements Python isolés")),
    "rust": ("Rust", "compilateur"),
    "cargo": ("Cargo", _("paquets Rust")),
    "go": ("Go", "compilateur"),
    "nodejs-default": ("Node.js", ""),
    "npm-default": ("npm", _("paquets Node.js")),
    "osc": ("osc", _("Open Build Service (openSUSE)")),
    "rpm-build": ("rpm-build", _("construction de paquets RPM")),
    "rpmlint": ("rpmlint", _("vérification des paquets RPM")),
    "quilt": ("quilt", _("gestion de correctifs")),
    "spyder": ("Spyder", _("environnement de développement Python")),
    "flatpak:com.vscodium.codium": ("VSCodium", _("éditeur de code (VS Code sans télémétrie)")),
    "ollama": ("Ollama", _("modèles d'IA en local, sans Internet une fois le modèle téléchargé (« ollama run … »)")),
    "steam": ("Steam", ""),
    "lutris": ("Lutris", _("jeux de toutes provenances")),
    "gamemode": ("GameMode", _("performances pendant les jeux")),
    "mangohud": ("MangoHud", _("affichage FPS et températures en jeu")),
    "gamescope": ("Gamescope", _("compositeur pour les jeux")),
    "wine": ("Wine", _("logiciels Windows")),
    "wine-mono": ("Wine Mono", _(".NET pour Wine")),
    "wine-gecko": ("Wine Gecko", _("pages web dans Wine")),
    "protontricks": ("Protontricks", _("réglages Proton (Steam)")),
    "flatpak:org.prismlauncher.PrismLauncher": ("Prism Launcher", "Minecraft"),
    "flatpak:com.usebottles.bottles": ("Bottles", _("logiciels Windows")),
    "nvidia-open-driver-G06-signed-kmp-meta": (_("Pilote NVIDIA (module noyau)"), _("module open signé")),
    "nvidia-video-G06": (_("Pilote NVIDIA (affichage)"), ""),
    "nvidia-gl-G06-32bit": (_("Pilote NVIDIA — 32 bits"), _("jeux 32 bits")),
    "nvidia-compute-utils-G06": (_("nvidia-smi et CUDA"), ""),
}


# onglet Système : profils appliqués par l'aide profil (même liste que la page de l'installateur, packagechooser)
PROFILS = [
    ("equilibre", (_("Équilibré"), _("Réglages d'origine de Tumbleweed. Le bon choix pour la plupart des usages."),
                   "emblem-default-symbolic")),
    ("jeux", (_("Jeux"), _("Ordonnanceur scx_lavd : le jeu reste fluide même quand d'autres programmes travaillent. "
                           "Réglages conseillés pour Steam et Proton. Sans redémarrage."), "input-gaming-symbolic")),
    ("securite", (_("Sécurité"), _("Mémoire effacée dès qu'elle est libérée, noyau verrouillé, adresses du noyau "
                                   "cachées. Un peu plus lent ; certains très anciens programmes peuvent ne plus "
                                   "démarrer. Redémarrage nécessaire."), "security-high-symbolic")),
]


def libelle_instantane(i):
    """Titre lisible d'un instantané snapper (descriptions écrites par zypper, l'installateur, le Centre…)."""
    d, apres = i["description"].strip(), i["type"] == "post"
    if d.startswith("zypp(") or (apres and not d):
        return (_("Après une mise à jour ou une installation de logiciels") if apres
                else _("Avant une mise à jour ou une installation de logiciels"))
    if d.startswith("Centre KemmOS : profil "):
        # description écrite en français par l'aide profil : nom du profil traduit à l'affichage
        return _("Avant le passage au profil {nom}").format(nom=_(d[len("Centre KemmOS : profil "):]))
    if d.startswith("Point de restauration : "):
        return d[len("Point de restauration : "):]
    # kemmos-snapshot-rollback : snapper rollback garde une copie du système remplacé (« Restauration du snapshot N »)
    m = re.match(r"(?:Restauration du snapshot|rollback backup of #?)\s*(\d+)", d)
    if m:
        return _("Avant le retour au point n° {n}").format(n=m.group(1))
    # n° 1 = système installé ; après une restauration, il n'est plus en service : c'est l'ancien système
    if d == "Système KemmOS":
        return _("Système tout juste installé") if i["actif"] else _("Ancien système (avant une restauration)")
    return {"timeline": _("Copie automatique"),
            "Installation KemmOS": _("Fin de l'installation")}.get(d, d or _("Sans description"))


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


def sortie(cmd):
    try:
        return subprocess.run(cmd, capture_output=True, text=True, timeout=10).stdout.strip()
    except (OSError, subprocess.SubprocessError):
        return ""


def taille(n):
    """« 1,2 Go » en français et en breton, « 1.2 GB » en anglais."""
    n = float(n)
    francais = LANGUE in ("fr", "br")
    for u in (("o", "Ko", "Mo", "Go", "To") if francais else ("B", "KB", "MB", "GB", "TB")):
        if n < 1024 or u in ("To", "TB"):
            t = f"{n:.0f} {u}" if u in ("o", "B") else f"{n:.1f} {u}"
            return t.replace(".", ",") if francais else t
        n /= 1024


def os_release():
    infos = {}
    for ligne in lire("/etc/os-release").splitlines():
        if "=" in ligne:
            k, v = ligne.split("=", 1)
            infos[k] = v.strip('"')
    return infos


def peripheriques_pci():
    """[(adresse, classe 0xCCSSPP, fabricant, pilote ou "")] des périphériques PCI."""
    try:
        noms = sorted(os.listdir(PCI))
    except OSError:
        return []
    res = []
    for d in noms:
        pilote = os.path.basename(os.path.realpath(f"{PCI}/{d}/driver")) if os.path.exists(f"{PCI}/{d}/driver") else ""
        res.append((d, lire(f"{PCI}/{d}/class"), lire(f"{PCI}/{d}/vendor"), pilote))
    return res


def carte_nvidia():
    return any(f == "0x10de" and c.startswith("0x03") for _a, c, f, _p in peripheriques_pci())


def nom_pci(adresse):
    """Nom lisible (lspci) : « Intel Corporation Wi-Fi 6 AX201 »."""
    champs = re.findall(r'"([^"]*)"', sortie(["lspci", "-mm", "-s", adresse]))
    return " ".join(champs[1:3]) if len(champs) >= 3 else adresse


# Classes PCI dont l'absence de pilote prive d'une fonction visible (affichage, réseau, son)
CLASSES_ESSENTIELLES = {"0x0300": _("Carte graphique"), "0x0302": _("Carte graphique"), "0x0380": _("Carte graphique"),
                        "0x0200": _("Carte réseau filaire"), "0x0280": _("Carte Wi-Fi"), "0x0403": _("Carte son")}


def sans_pilote():
    """[(type, nom)] des périphériques essentiels sans pilote chargé."""
    return [(CLASSES_ESSENTIELLES[c[:6]], nom_pci(a)) for a, c, _f, p in peripheriques_pci()
            if c[:6] in CLASSES_ESSENTIELLES and not p]


def etat_rfkill(genre):
    """None : aucun interrupteur de ce genre ; sinon (bloqué matériel/BIOS, bloqué logiciel)."""
    base = "/sys/class/rfkill"
    try:
        noms = os.listdir(base)
    except OSError:
        return None
    etats = [(lire(f"{base}/{n}/hard") == "1", lire(f"{base}/{n}/soft") == "1")
             for n in noms if lire(f"{base}/{n}/type") == genre]
    if not etats:
        return None
    return all(h for h, _s in etats), all(s for _h, s in etats)


def sante_batterie():
    """[(nom, capacité restante en % de l'origine)] des batteries qui donnent l'information."""
    base = "/sys/class/power_supply"
    res = []
    try:
        noms = sorted(os.listdir(base))
    except OSError:
        return res
    for n in noms:
        if lire(f"{base}/{n}/type") != "Battery":
            continue
        for plein, origine in (("energy_full", "energy_full_design"), ("charge_full", "charge_full_design")):
            try:
                pct = 100 * int(lire(f"{base}/{n}/{plein}")) / int(lire(f"{base}/{n}/{origine}"))
            except (ValueError, ZeroDivisionError):
                continue
            res.append((n, min(pct, 100)))
            break
    return res


def memoire():
    """(total, utilisée) en octets, d'après /proc/meminfo."""
    infos = {}
    for l in lire("/proc/meminfo").splitlines():
        cle, _s, val = l.partition(":")
        if val.strip().endswith("kB"):
            infos[cle] = int(val.split()[0]) * 1024
    total = infos.get("MemTotal", 0)
    return total, total - infos.get("MemAvailable", total)


def cameras():
    """Noms des caméras présentes (pilote chargé)."""
    try:
        noms = os.listdir("/sys/class/video4linux")
    except OSError:
        return []
    return sorted({lire(f"/sys/class/video4linux/{n}/name") for n in noms} - {""})


def sans_accents(texte):
    return "".join(c for c in unicodedata.normalize("NFD", texte.lower()) if not unicodedata.combining(c))


def paquets_installes(noms):
    """Éléments de @noms présents. --whatprovides : certains noms des groupes sont des capacités
    (qemu-kvm est fourni par un paquet d'un autre nom), comme zypper les résout à l'installation."""
    return {n for n in noms
            if subprocess.run(["rpm", "-q", "--quiet", "--whatprovides", n]).returncode == 0}


def flatpaks_installes():
    return set(sortie(["flatpak", "list", "--system", "--app", "--columns=application"]).split())


def date_base_virus():
    """Date (epoch) de la dernière mise à jour de la base ClamAV, None si elle n'est pas téléchargée."""
    f = lambda n: os.path.join(BASE_VIRUS, n)
    if not any(os.path.exists(f(n)) for n in ("main.cvd", "main.cld")):
        return None
    dates = [os.path.getmtime(f(n)) for n in ("daily.cld", "daily.cvd") if os.path.exists(f(n))]
    return max(dates) if dates else None


def quarantaine():
    try:
        with open(QUARANTAINE) as f:
            return json.load(f)
    except (OSError, ValueError):
        return []


def supports_amovibles():
    """[(nom, chemin)] des clés USB / disques externes montés (/run/media/<utilisateur>/…)."""
    res = []
    for m in Gio.VolumeMonitor.get().get_mounts():
        racine = m.get_root().get_path()
        if racine and racine.startswith("/run/media/"):
            res.append((m.get_name(), racine))
    return res


def nm_champs(ligne, n):
    """Découpe une ligne de « nmcli -t » (deux-points échappés en \\:)."""
    parts = re.split(r"(?<!\\):", ligne, maxsplit=n - 1)
    return [p.replace("\\:", ":").replace("\\\\", "\\") for p in parts] + [""] * (n - len(parts))


def connexions(actives):
    cmd = ["nmcli", "-t", "-f", "UUID,TYPE,DEVICE,NAME", "connection", "show"] + (["--active"] if actives else [])
    return [nm_champs(l, 4) for l in sortie(cmd).splitlines() if l]


def infos_appareil(dev):
    """{'IP4.ADDRESS': [...], 'IP4.GATEWAY': [...], 'IP4.DNS': [...], 'GENERAL.HWADDR': [...]}"""
    res = {}
    for l in sortie(["nmcli", "-t", "-f", "GENERAL.HWADDR,IP4.ADDRESS,IP4.GATEWAY,IP4.DNS", "device", "show",
                     dev]).splitlines():
        cle, val = nm_champs(l, 2)
        if val:
            res.setdefault(cle.split("[")[0], []).append(val)
    return res


def reglages_connexion(uuid):
    res = {}
    for l in sortie(["nmcli", "-t", "-f", "ipv4.method,ipv4.addresses,ipv4.gateway,ipv4.dns", "connection", "show",
                     uuid]).splitlines():
        cle, val = nm_champs(l, 2)
        res[cle] = val
    return res


def charger_groupes():
    """Groupes affichés : chaque sous-groupe à la place de son groupe (Utilisateurs avancés, 1.7.1)."""
    try:
        with open(GROUPES) as f:
            groupes = [g for g in (yaml.safe_load(f) or []) if g.get("name")]
    except (OSError, yaml.YAMLError):
        return []
    res = []
    for g in groupes:
        sous = [s for s in g.get("subgroups") or [] if s.get("name")]
        res.extend(sous if sous else [g])
    return res


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, app):
        # breton : libellés d'onglets plus longs (« Taolenn-stur » était coupé à 1000 pixels)
        super().__init__(application=app, title=_("Centre KemmOS"), default_width=1120 if LANGUE == "br" else 1000,
                         default_height=720)
        self.occupe = False

        self.toasts = Adw.ToastOverlay()
        vue = Adw.ToolbarView()
        entete = Adw.HeaderBar()
        self.pile = Adw.ViewStack()
        selecteur = Adw.ViewSwitcher(stack=self.pile, policy=Adw.ViewSwitcherPolicy.WIDE)
        entete.set_title_widget(selecteur)
        actualiser = Gtk.Button(icon_name="view-refresh-symbolic", tooltip_text=_("Actualiser"))
        actualiser.connect("clicked", lambda _b: self.actualiser())
        entete.pack_end(actualiser)
        # recherche (1.15.0) : dans tous les onglets ; il suffit de taper au clavier pour commencer
        self.btn_recherche = Gtk.ToggleButton(icon_name="system-search-symbolic", tooltip_text=_("Rechercher (Ctrl+F)"))
        entete.pack_start(self.btn_recherche)
        vue.add_top_bar(entete)
        self.recherche = Gtk.SearchEntry(placeholder_text=_("Rechercher un réglage : pare-feu, caméra, sauvegarde…"),
                                         hexpand=True)
        barre = Gtk.SearchBar(child=Adw.Clamp(child=self.recherche, maximum_size=560), show_close_button=True)
        barre.connect_entry(self.recherche)
        barre.set_key_capture_widget(self)
        barre.bind_property("search-mode-enabled", self.btn_recherche, "active",
                            GObject.BindingFlags.BIDIRECTIONAL | GObject.BindingFlags.SYNC_CREATE)
        barre.connect("notify::search-mode-enabled", lambda b, _p: b.get_search_mode() or self.fin_recherche())
        self.barre_recherche = barre
        self.recherche.connect("search-changed", lambda e: self.rechercher(e.get_text()))
        self.recherche.connect("activate", lambda _e: self.premier_resultat())
        raccourci = Gtk.ShortcutController()
        raccourci.add_shortcut(Gtk.Shortcut(trigger=Gtk.ShortcutTrigger.parse_string("<Control>f"),
                                            action=Gtk.CallbackAction.new(lambda *_a: barre.set_search_mode(True) or True)))
        self.add_controller(raccourci)
        vue.add_top_bar(barre)
        vue.set_content(self.pile)
        self.toasts.set_child(vue)
        self.set_content(self.toasts)

        self.page_etat = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_etat, "etat", _("Tableau de bord"), "computer-symbolic")
        self.page_logiciels = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_logiciels, "logiciels", _("Logiciels"),
                                       "system-software-install-symbolic")
        self.page_securite = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_securite, "securite", _("Sécurité"), "security-high-symbolic")
        self.page_reseau = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_reseau, "reseau", _("Réseau"), "network-workgroup-symbolic")
        self.page_systeme = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_systeme, "systeme", _("Système"), "preferences-system-symbolic")
        self.page_aide = Adw.PreferencesPage()
        self.pile.add_titled_with_icon(self.page_aide, "aide", _("Aide"), "help-browser-symbolic")
        self.page_recherche = Adw.PreferencesPage()     # résultats de la recherche (pas d'onglet)
        self.pile.add_named(self.page_recherche, "recherche")
        self.onglet_avant = "etat"
        self.resultats = []

        self.groupes_widgets = []
        self.av = None             # analyse antivirus en cours
        self.av_resultat = None    # résultat de la dernière analyse
        self.av_maj = False        # téléchargement de la base de virus en cours
        # clé USB branchée ou retirée : liste des analyses à jour
        self.moniteur = Gio.VolumeMonitor.get()
        for signal in ("mount-added", "mount-removed"):
            self.moniteur.connect(signal, lambda *_a: self.av is None and self.construire_securite())
        self.construire_aide()
        self.actualiser()

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

    def vider(self, page):
        # page reconstruite après un réglage : garder la position de défilement (sinon retour en haut)
        # le bouton cliqué va disparaître : sans ça, GTK donne le focus au premier élément de la page et y défile
        self.set_focus(None)
        defil = page.get_first_child()
        if isinstance(defil, Gtk.ScrolledWindow) and defil.get_vadjustment().get_value() > 0:
            adj = defil.get_vadjustment()
            pos = adj.get_value()
            # la page regrandit en plusieurs fois : remettre la position à chaque changement pendant 1 s
            h = adj.connect("changed", lambda a: a.set_value(pos))
            GLib.timeout_add(1000, lambda: (adj.disconnect(h), False)[1])
        for g in list(getattr(page, "_groupes", [])):
            page.remove(g)
        page._groupes = []

    def ajouter(self, page, groupe):
        page.add(groupe)
        page._groupes = getattr(page, "_groupes", []) + [groupe]

    def ligne(self, titre, valeur, icone=None, etat=None):
        r = Adw.ActionRow(title=titre, subtitle=valeur)
        r.set_subtitle_selectable(True)
        if icone:
            r.add_prefix(Gtk.Image(icon_name=icone))
        if etat is not None:
            r.add_suffix(self.pastille(etat))
        return r

    @staticmethod
    def pastille(ok, info=None):
        # coche en texte : emblem-ok-symbolic n'existe pas dans le thème d'icônes Newaita (icône cassée)
        if ok:
            p = Gtk.Label(label="✔", tooltip_text=info)
            p.add_css_class("success")
            p.add_css_class("title-4")
        else:
            p = Gtk.Image(icon_name="dialog-warning-symbolic", tooltip_text=info)
            p.add_css_class("warning")
        return p

    def bouton(self, label, rappel, style=None):
        b = Gtk.Button(label=label, valign=Gtk.Align.CENTER)
        if style:
            b.add_css_class(style)
        b.connect("clicked", lambda _b: rappel())
        return b

    def lancer_appli(self, desktop_id, secours=None):
        try:   # appli absente : TypeError (« constructor returned NULL ») et non None
            info = DesktopAppInfo.new(desktop_id)
        except TypeError:
            info = None
        if info:
            info.launch([], None)
        elif secours and shutil.which(secours[0]):
            subprocess.Popen(secours, start_new_session=True)
        else:
            self.toast(_("Application non installée"))

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

    # ---------- recherche (1.15.0) ----------

    def lignes_de(self, widget):
        """Toutes les lignes (Adw.PreferencesRow) d'une page, dans l'ordre d'affichage."""
        enfant = widget.get_first_child()
        while enfant is not None:
            if isinstance(enfant, Adw.PreferencesRow):
                yield enfant
            else:
                yield from self.lignes_de(enfant)
            enfant = enfant.get_next_sibling()

    def rechercher(self, texte):
        mots = sans_accents(texte).split()
        if not mots:
            self.fin_recherche()
            return
        if self.pile.get_visible_child_name() != "recherche":
            self.onglet_avant = self.pile.get_visible_child_name()
        onglets = [("etat", _("Tableau de bord"), self.page_etat), ("logiciels", _("Logiciels"), self.page_logiciels),
                   ("securite", _("Sécurité"), self.page_securite), ("reseau", _("Réseau"), self.page_reseau),
                   ("systeme", _("Système"), self.page_systeme), ("aide", _("Aide"), self.page_aide)]
        trouves = []
        for nom, titre_onglet, page in onglets:
            for ligne in self.lignes_de(page):
                groupe = ligne.get_ancestor(Adw.PreferencesGroup)
                titre_groupe = groupe.get_title() if groupe else ""
                sous = ligne.get_subtitle() if isinstance(ligne, Adw.ActionRow) else ""
                cible = sans_accents(" ".join(x or "" for x in (ligne.get_title(), sous, titre_groupe, titre_onglet)))
                if all(m in cible for m in mots):
                    trouves.append((nom, titre_onglet, titre_groupe, ligne))
        page = self.page_recherche
        for g in list(getattr(page, "_groupes", [])):
            page.remove(g)
        page._groupes = []
        g = Adw.PreferencesGroup(title=ngettext("{n} résultat", "{n} résultats", len(trouves)).format(n=len(trouves)))
        self.resultats = []
        for nom, titre_onglet, titre_groupe, ligne in trouves[:40]:
            r = Adw.ActionRow(title=GLib.markup_escape_text(ligne.get_title() or titre_groupe),
                              subtitle=GLib.markup_escape_text(" › ".join(x for x in (titre_onglet, titre_groupe) if x)),
                              activatable=True)
            r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
            r.connect("activated", lambda _r, n=nom, l=ligne: self.aller_a(n, l))
            g.add(r)
            self.resultats.append((nom, ligne))
        if not trouves:
            g.add(Adw.ActionRow(title=_("Rien trouvé"), subtitle=_("Essayez un autre mot (ex. wifi, mise à jour, "
                                                                   "Windows, démarrage)")))
        self.ajouter(page, g)
        self.pile.set_visible_child_name("recherche")

    def premier_resultat(self):
        if self.resultats:
            self.aller_a(*self.resultats[0])

    def aller_a(self, nom, ligne):
        self.onglet_avant = nom
        self.barre_recherche.set_search_mode(False)
        self.pile.set_visible_child_name(nom)
        # la ligne trouvée : amenée en haut de la page (défilement) et mise en évidence un instant
        GLib.timeout_add(150, self.defiler_vers, ligne)
        ligne.add_css_class("accent")
        GLib.timeout_add(2500, lambda: ligne.remove_css_class("accent") or False)

    @staticmethod
    def defiler_vers(ligne):
        defil = ligne.get_ancestor(Gtk.ScrolledWindow)
        if defil is not None:
            ok, point = ligne.compute_point(defil, Graphene.Point())
            if ok:
                adj = defil.get_vadjustment()
                adj.set_value(min(max(adj.get_value() + point.y - 90, 0), adj.get_upper() - adj.get_page_size()))
        ligne.grab_focus()
        return False

    def fin_recherche(self):
        if self.pile.get_visible_child_name() == "recherche":
            self.pile.set_visible_child_name(self.onglet_avant or "etat")

    def actualiser(self):
        self.construire_etat()
        if not self.occupe:
            self.construire_logiciels()
        if self.av is None:
            self.construire_securite()
        self.construire_reseau()
        self.construire_systeme()

    # ---------- Tableau de bord ----------

    def construire_etat(self):
        page = self.page_etat
        self.vider(page)
        rel = os_release()

        g = Adw.PreferencesGroup(title=_("Système"))
        g.add(self.ligne(_("Version"), rel.get("PRETTY_NAME", "KemmOS"), "computer-symbolic"))
        g.add(self.ligne(_("Noyau"), os.uname().release, "system-run-symbolic"))
        demarre = time.time() - float(lire("/proc/uptime", "0").split()[0])
        # TRANSLATORS: format de strftime (jour/mois/année à heure:minute)
        # xgettext:no-python-format
        g.add(self.ligne(_("Démarré le"), time.strftime(_("%d/%m/%Y à %H:%M"), time.localtime(demarre)),
                         "preferences-system-time-symbolic"))
        self.ajouter(page, g)

        # Mises à jour (état écrit par kemmos-update, vérifié toutes les heures)
        g = Adw.PreferencesGroup(title=_("Mises à jour"))
        try:
            with open(STATUT_MAJ) as f:
                s = json.load(f)
        except (OSError, ValueError):
            s = None
        if s is None:
            g.add(self.ligne(_("État"), _("Pas encore vérifié"), "software-update-available-symbolic", False))
        else:
            sys_n, fw, fp = s.get("system", -1), s.get("firmware", 0), max(s.get("flatpak", 0), 0)
            # TRANSLATORS: format de strftime (jour/mois à heure:minute)
            # xgettext:no-python-format
            quand = time.strftime(_("%d/%m à %H:%M"), time.localtime(s.get("timestamp", 0)))
            if sys_n < 0:
                txt, ok = _("Impossible de vérifier (voir KemmOS-Update)"), False
            elif sys_n + fw + fp == 0:
                txt, ok = _("Le système est à jour"), True
            else:
                parts = [ngettext("{n} paquet", "{n} paquets", sys_n).format(n=sys_n)] if sys_n else []
                parts += [ngettext("{n} application Flatpak", "{n} applications Flatpak", fp).format(n=fp)] if fp else []
                parts += [ngettext("{n} firmware", "{n} firmwares", fw).format(n=fw)] if fw else []
                txt, ok = _("À mettre à jour : {liste}").format(liste=", ".join(parts)), False
            r = self.ligne(_("État"), _("{txt}\nDernière vérification : {quand}").format(txt=txt, quand=quand),
                           "software-update-available-symbolic", ok)
            g.add(r)
            if s.get("reboot"):
                g.add(self.ligne(_("Redémarrage"), _("Recommandé (noyau ou composant système mis à jour)"),
                                 "system-reboot-symbolic", False))
            p = s.get("prudent") or {}
            if p.get("actif") and p.get("version"):
                v = p["version"]
                g.add(self.ligne(_("Version de Tumbleweed"), _("{date} — mode prudent ({n} jours de recul au moins, "
                                                              "onglet Système)").format(
                    date=f"{v[6:8]}/{v[4:6]}/{v[0:4]}", n=p.get("delai", 3)), "emblem-system-symbolic"))
            n = s.get("snapshots", "?")
            # KemmOS-Update compte toutes les lignes de « snapper list », dont le n° 0 (« current ») et le système en
            # service : mêmes points que la liste de l'onglet Système
            if isinstance(n, int):
                n = max(n - 2, 0)
            g.add(self.ligne(_("Instantanés (snapshots)"),
                             ngettext("{n} point de restauration (onglet Système)",
                                      "{n} points de restauration (onglet Système)", n).format(n=n)
                             if isinstance(n, int) else _("{n} points de restauration (onglet Système)").format(n=n),
                             "document-open-recent-symbolic"))
        r = Adw.ActionRow(title=_("Vérifier maintenant"),
                          subtitle=_("La mise à jour se lance depuis l'icône KemmOS-Update de la barre du haut"))
        r.add_suffix(self.bouton(_("Vérifier"), self.verifier_maj))
        g.add(r)
        self.ajouter(page, g)

        # Sécurité
        g = Adw.PreferencesGroup(title=_("Sécurité"))
        selinux = lire("/sys/fs/selinux/enforce")
        g.add(self.ligne("SELinux", {"1": _("Actif (enforcing)"), "0": _("Permissif : protection désactivée")}
                         .get(selinux, _("Absent")), "security-high-symbolic", selinux == "1"))
        pf = sortie(["systemctl", "is-active", "firewalld"]) == "active"
        g.add(self.ligne(_("Pare-feu"), _("Actif") if pf else _("Inactif"), "network-wired-symbolic", pf))
        sb = None
        try:
            with open("/sys/firmware/efi/efivars/SecureBoot-8be4df61-93ca-11d2-aa0d-00e098032b8c", "rb") as f:
                sb = f.read()[-1] == 1
        except OSError:
            pass
        g.add(self.ligne(_("Démarrage sécurisé (Secure Boot)"),
                         {True: _("Actif"), False: _("Désactivé dans le BIOS/UEFI"), None: _("Inconnu")}[sb],
                         "channel-secure-symbolic", sb))
        chiffre = "crypt" in sortie(["lsblk", "-rno", "TYPE"]).split()
        g.add(self.ligne(_("Chiffrement du disque"), _("Actif (LUKS2)") if chiffre else
                         _("Non chiffré (choix fait à l'installation)"), "drive-harddisk-symbolic", chiffre or None))
        r = Adw.ActionRow(title=_("Pare-feu, antivirus, confidentialité"), subtitle=_("Réglages de l'onglet Sécurité"))
        r.add_prefix(Gtk.Image(icon_name="preferences-system-privacy-symbolic"))
        r.add_suffix(self.bouton(_("Voir"), lambda: self.pile.set_visible_child_name("securite")))
        g.add(r)
        self.ajouter(page, g)

        self.ajouter(page, self.groupe_materiel())

        # Disque, énergie, sauvegarde
        g = Adw.PreferencesGroup(title=_("Confort"))
        st = os.statvfs("/")
        libre, total = st.f_bavail * st.f_frsize, st.f_blocks * st.f_frsize
        g.add(self.ligne(_("Espace disque"), _("{libre} libres sur {total}").format(libre=taille(libre), total=taille(total)),
                         "drive-harddisk-symbolic", libre > 10 * 1024 ** 3))
        # Santé des disques (SMART lu par UDisks2, sans mot de passe) : même analyse que le bilan de santé
        objets = BILAN.objets_udisks() if BILAN else {}
        pannes = BILAN.analyse_smart(objets) if objets else []
        for _cle, texte, urgent in pannes:
            g.add(self.ligne(_("Santé des disques"), texte, "drive-harddisk-symbolic", False))
        if not pannes and objets and BILAN.nb_surveilles(objets):
            g.add(self.ligne(_("Santé des disques"), _("Aucun signe de panne (auto-diagnostic SMART)"),
                             "drive-harddisk-symbolic", True))
        profil = sortie(["powerprofilesctl", "get"])
        noms = {"power-saver": _("Économie d'énergie"), "balanced": _("Équilibré"), "performance": _("Performance")}
        r = self.ligne(_("Profil d'énergie"), noms.get(profil, profil or _("Indisponible")),
                       "power-profile-balanced-symbolic")
        r.add_suffix(self.bouton(_("Changer"), lambda: self.lancer_appli(
            "gnome-power-panel.desktop", ["gnome-control-center", "power"])))
        g.add(r)
        texte, recente = self.etat_sauvegarde()
        r = self.ligne(_("Sauvegarde des fichiers personnels"), texte, "drive-multidisk-symbolic", recente)
        r.add_suffix(self.bouton(_("Ouvrir"), lambda: self.lancer_appli("org.gnome.DejaDup.desktop")))
        g.add(r)
        # sauvegarde vérifiée (1.15.0) : quelques fichiers relus pour de vrai dans la dernière sauvegarde
        if os.path.exists(VERIF_SAUVEGARDE) and self.sauvegarde_faite():
            v = {}
            try:
                with open(ETAT_VERIF) as f:
                    v = json.load(f)
            except (OSError, ValueError):
                pass
            if getattr(self, "verif_en_cours", False):
                txt, ok = _("Vérification en cours : relecture de quelques fichiers…"), None
            elif v.get("ok") is True:
                txt, ok = ngettext("Vérifiée le {date} : {n} fichier relu, identique à l'original",
                                   "Vérifiée le {date} : {n} fichiers relus, identiques aux originaux",
                                   v.get("fichiers", 0)).format(
                    date=time.strftime("%d/%m/%Y", time.localtime(v.get("date", 0))), n=v.get("fichiers", 0)), True
            elif v.get("ok") is False:
                txt, ok = _("Échec de la vérification le {date} : {message}").format(
                    date=time.strftime("%d/%m/%Y", time.localtime(v.get("date", 0))), message=v.get("message", "")), False
            else:
                txt, ok = (_("Pas encore vérifiée. Branchez le disque de sauvegarde puis « Vérifier » ; ensuite, "
                             "c'est automatique après une sauvegarde, une fois par mois.") +
                           (" (" + v["message"] + ")" if v.get("message") else "")), None
            r = self.ligne(_("Sauvegarde vérifiée"), txt, "emblem-ok-symbolic" if ok else "dialog-question-symbolic", ok)
            b = self.bouton(_("Vérifier"), self.verifier_sauvegarde)
            b.set_sensitive(not getattr(self, "verif_en_cours", False))
            r.add_suffix(b)
            g.add(r)
        rappel = Adw.SwitchRow(title=_("Me rappeler de sauvegarder"),
                               subtitle=_("Notification au plus une fois par semaine si la dernière sauvegarde "
                                          "a plus de 30 jours"))
        rappel.add_prefix(Gtk.Image(icon_name="alarm-symbolic"))
        rappel.set_active(lire(RAPPEL) != "jamais")
        rappel.connect("notify::active", lambda s, _p: self.regler_rappel(s.get_active()))
        g.add(rappel)
        self.ajouter(page, g)

    def groupe_materiel(self):
        g = Adw.PreferencesGroup(title=_("Matériel"))
        manquants = sans_pilote()
        for genre, nom in manquants:
            g.add(self.ligne(_("{genre} sans pilote").format(genre=genre),
                             _("{nom}\nCe matériel ne fonctionnera pas tant qu'aucun pilote n'est chargé. Joignez un "
                               "rapport de diagnostic (onglet Aide) à votre demande d'aide.").format(nom=nom),
                             "dialog-warning-symbolic", False))
        nv = [(a, p) for a, c, f, p in peripheriques_pci() if f == "0x10de" and c.startswith("0x03")]
        if nv:
            officiel = any(p == "nvidia" for _a, p in nv)
            r = self.ligne(_("Carte NVIDIA"), _("Pilote officiel NVIDIA actif") if officiel else
                           _("Pilote libre (nouveau) ou aucun : performances réduites, jeux déconseillés. "
                             "Installez le groupe « Pilote NVIDIA (RTX) »."), "video-display-symbolic", officiel)
            if not officiel:
                r.add_suffix(self.bouton(_("Voir"), lambda: self.pile.set_visible_child_name("logiciels")))
            g.add(r)
        if not manquants and not nv:
            g.add(self.ligne(_("Pilotes"), _("Carte graphique, réseau et son : pilotes chargés"),
                             "video-display-symbolic", True))
        bt = etat_rfkill("bluetooth")
        if bt is None:
            g.add(self.ligne("Bluetooth", _("Aucun adaptateur détecté. Si cet ordinateur en a un, vérifiez qu'il "
                                            "est activé dans le BIOS/UEFI."), "bluetooth-symbolic"))
        elif bt[0]:
            g.add(self.ligne("Bluetooth", _("Bloqué par un interrupteur matériel ou le BIOS/UEFI"),
                             "bluetooth-disabled-symbolic", False))
        else:
            g.add(self.ligne("Bluetooth", _("Désactivé (Paramètres › Bluetooth)") if bt[1] else _("Disponible"),
                             "bluetooth-symbolic"))
        wifi = etat_rfkill("wlan")
        if wifi and wifi[0]:
            g.add(self.ligne("Wi-Fi", _("Bloqué par un interrupteur matériel, une touche Fn ou le BIOS/UEFI"),
                             "network-wireless-disabled-symbolic", False))
        total, utilisee = memoire()
        if total:
            pct = round(100 * utilisee / total)
            g.add(self.ligne(_("Mémoire vive"), _("{total} — {pct} % utilisés").format(total=taille(total), pct=pct),
                             "utilities-system-monitor-symbolic", pct < 90))
        t = BILAN.temperature_processeur() if BILAN else None
        if t is not None:
            g.add(self.ligne(_("Température du processeur"), f"{round(t)} °C" + (
                _(" — très chaud : aérations bouchées ?") if t >= 90 else ""), "temperature-symbolic", t < 90))
        for nom, usure in (BILAN.usure_ssd(BILAN.objets_udisks()) if BILAN else []):
            g.add(self.ligne(_("Usure du SSD ({nom})").format(nom=nom),
                             _("{pct} % de sa durée de vie utilisée").format(pct=usure)
                             + (_(" — à remplacer bientôt") if usure >= 90 else ""), "drive-harddisk-solidstate-symbolic",
                             usure < 90))
        for nom, pct in sante_batterie():
            g.add(self.ligne(_("Batterie ({nom})").format(nom=nom),
                             _("Capacité : {pct} % de la capacité d'origine").format(pct=round(pct))
                             + ("" if pct >= 60 else _(" — usée, autonomie réduite")),
                             "battery-symbolic", pct >= 60))
        return g

    def regler_interrupteur(self, interrupteur, cmd_oui, cmd_non, si_oui, si_non, si_echec, apres=None):
        """Interrupteur appliqué par un aide pkexec (cmd_oui / cmd_non) ; remis en place en cas d'échec.
        apres() : appelé après un réglage réussi (ex. reconstruire la page)."""
        if getattr(interrupteur, "_retour", False):   # remise en place après un échec : rien à faire
            interrupteur._retour = False
            return
        actif = interrupteur.get_active()
        interrupteur.set_sensitive(False)
        try:
            p = Gio.Subprocess.new(["pkexec", *(cmd_oui if actif else cmd_non)],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            p = None
            erreur = e.message

        def fini(proc, res):
            ok, out, _err = proc.communicate_utf8_finish(res)
            code = proc.get_exit_status()
            interrupteur.set_sensitive(True)
            if code == 0:
                self.toast(si_oui if actif else si_non)
                if apres:
                    apres()
                return
            interrupteur._retour = True
            interrupteur.set_active(not actif)
            if code in (126, 127):
                self.toast(_("Annulé (mot de passe non fourni)"))
            else:
                lignes = [l for l in (out or "").splitlines() if l.strip()]
                self.toast(si_echec + (" : " + lignes[-1] if lignes else ""))
        if p is None:
            interrupteur.set_sensitive(True)
            interrupteur._retour = True
            interrupteur.set_active(not actif)
            self.toast(erreur)
            return
        p.communicate_utf8_async(None, None, fini)

    def regler_rappel(self, actif):
        # « jamais » : plus de rappel ; vide : rappel dès la prochaine session si nécessaire
        os.makedirs(os.path.dirname(RAPPEL), exist_ok=True)
        with open(RAPPEL, "w") as f:
            f.write("" if actif else "jamais\n")
        self.toast(_("Rappel de sauvegarde activé") if actif else _("Rappel de sauvegarde désactivé"))

    @staticmethod
    def sauvegarde_faite():
        """Déjà Dup a-t-il déjà fait une sauvegarde (indépendant de la langue) ?"""
        source = Gio.SettingsSchemaSource.get_default()
        schema = source.lookup("org.gnome.DejaDup", True) if source else None
        return bool(schema and schema.has_key("last-backup")
                    and Gio.Settings.new("org.gnome.DejaDup").get_string("last-backup"))

    def etat_sauvegarde(self):
        source = Gio.SettingsSchemaSource.get_default()
        schema = source.lookup("org.gnome.DejaDup", True) if source else None
        if schema is None:
            return _("Déjà Dup n'est pas installé"), False
        reglages = Gio.Settings.new("org.gnome.DejaDup")
        derniere = reglages.get_string("last-backup") if schema.has_key("last-backup") else ""
        auto = schema.has_key("periodic") and reglages.get_boolean("periodic")
        if not derniere:
            return _("Aucune sauvegarde pour l'instant — conseillé : un disque externe"), False
        quand = GLib.DateTime.new_from_iso8601(derniere, None)
        if quand is None:
            return _("Dernière sauvegarde : {derniere}").format(derniere=derniere), None
        d = quand.to_local().format("%d/%m/%Y à %H:%M")
        recente = time.time() - quand.to_unix() < 30 * 86400
        return (_("Dernière sauvegarde : {d}").format(d=d) + (_(" · automatique") if auto else "")
                + ("" if recente else _(" — plus de 30 jours")), recente)

    def verifier_sauvegarde(self):
        self.verif_en_cours = True
        self.construire_etat()

        def fini(proc, res):
            _ok, out, _err = proc.communicate_utf8_finish(res)
            self.verif_en_cours = False
            self.toast((out or "").strip().splitlines()[-1] if (out or "").strip() else _("Vérification terminée"))
            self.construire_etat()
        try:
            p = Gio.Subprocess.new([VERIF_SAUVEGARDE], Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
            p.communicate_utf8_async(None, None, fini)
        except GLib.Error as e:
            self.verif_en_cours = False
            self.toast(e.message)

    def verifier_maj(self):
        # autorisé sans mot de passe (règle polkit de kemmos-update)
        def fini(proc, res):
            try:
                proc.wait_finish(res)
            except GLib.Error:
                pass
            self.construire_etat()
            self.toast(_("Vérification terminée"))
        try:
            p = Gio.Subprocess.new(["systemctl", "start", "kemmos-update-check.service"],
                                   Gio.SubprocessFlags.NONE)
            self.toast(_("Vérification des mises à jour…"))
            p.wait_async(None, fini)
        except GLib.Error as e:
            self.toast(_("Échec : {message}").format(message=e.message))

    # ---------- Logiciels (groupes de l'installateur) ----------

    def construire_logiciels(self):
        page = self.page_logiciels
        self.vider(page)
        self.cases = []   # (groupe yml, élément, case, installé)
        intro = Adw.PreferencesGroup(
            title=_("Logiciels optionnels"),
            description=_("Les mêmes groupes que dans l'installateur. Cochez ce que vous voulez installer, "
                          "décochez ce que vous voulez retirer, puis « Appliquer ». Une connexion Internet "
                          "est nécessaire pour installer ; le mot de passe est demandé."))
        self.ajouter(page, intro)
        groupes = charger_groupes()
        if not groupes:
            intro.add(self.ligne(_("Liste indisponible"), GROUPES, "dialog-error-symbolic", False))
            return
        rpm_ok = paquets_installes(sorted({p for g in groupes for p in g.get("packages") or []
                                           if not str(p).startswith("flatpak:")}))
        fp_ok = flatpaks_installes()
        socle = lire(SOCLE).split()
        nvidia = carte_nvidia()
        for grp in groupes:
            nom, desc, icone = GROUPES_FR.get(grp["name"], (grp["name"], grp.get("description", ""),
                                                            "package-x-generic-symbolic"))
            elems = [str(p) for p in grp.get("packages") or []]
            faits = [p for p in elems if (p[8:] in fp_ok if p.startswith("flatpak:") else p in rpm_ok)]
            exp = Adw.ExpanderRow(title=nom, subtitle=desc + "\n" + _("Installé : {n}/{total}").format(
                n=len(faits), total=len(elems)))
            exp.set_subtitle_lines(4)
            exp.add_prefix(Gtk.Image(icon_name=icone, pixel_size=32))
            if len(faits) == len(elems):
                exp.add_suffix(self.pastille(True, _("Tout est installé")))
            sans_carte = grp["name"].startswith("NVIDIA") and not nvidia and not faits
            if sans_carte:
                exp.set_subtitle(desc + _("\nAucune carte NVIDIA détectée dans cet ordinateur."))
            cases_grp = []
            tout = Adw.ActionRow(title=_("Tout le groupe"))
            for label, val in ((_("Tout cocher"), True), (_("Tout décocher"), False)):
                tout.add_suffix(self.bouton(label, lambda v=val, c=cases_grp: [
                    x.set_active(v) for x in c if x.get_sensitive()], "flat"))
            tout.set_sensitive(not sans_carte)
            exp.add_row(tout)
            for e in elems:
                titre, info = NOMS.get(e, (e[8:] if e.startswith("flatpak:") else e, ""))
                sous = (e[8:] + _(" (Flathub)") if e.startswith("flatpak:") else e) + (f" — {info}" if info else "")
                case = Gtk.CheckButton(active=e in faits, valign=Gtk.Align.CENTER)
                r = Adw.ActionRow(title=titre, subtitle=sous, activatable_widget=case)
                r.add_prefix(case)
                if e in socle:
                    case.set_sensitive(False)
                    r.set_subtitle(sous + _(" — fait partie de KemmOS"))
                elif sans_carte:
                    case.set_sensitive(False)
                case.connect("toggled", lambda _c: self.maj_resume())
                cases_grp.append(case)
                self.cases.append((grp, e, case, e in faits))
                exp.add_row(r)
            intro.add(exp)

        self.groupe_resume = Adw.PreferencesGroup()
        self.resume = Adw.ActionRow(title=_("Aucune modification"))
        self.btn_annuler = self.bouton(_("Annuler"), self.annuler_choix)
        self.btn_appliquer = self.bouton(_("Appliquer"), self.preparer, "suggested-action")
        self.resume.add_suffix(self.btn_annuler)
        self.resume.add_suffix(self.btn_appliquer)
        self.groupe_resume.add(self.resume)
        self.ajouter(page, self.groupe_resume)
        self.maj_resume()

        self.journal_groupe = Adw.PreferencesGroup(title=_("Progression"))
        self.journal_groupe.set_visible(False)
        boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
        self.etape = Gtk.Label(xalign=0, wrap=True)
        self.etape.add_css_class("heading")
        boite.append(self.etape)
        self.barre = Gtk.ProgressBar()
        boite.append(self.barre)
        defil = Gtk.ScrolledWindow(min_content_height=260, vexpand=True)
        self.texte = Gtk.TextView(editable=False, monospace=True, cursor_visible=False,
                                  wrap_mode=Gtk.WrapMode.CHAR)
        defil.set_child(self.texte)
        boite.append(defil)
        self.journal_groupe.add(boite)
        self.ajouter(page, self.journal_groupe)

    def changements(self):
        """{nom du groupe : (groupe, [à installer], [à retirer])}, dans l'ordre des groupes."""
        res = {}
        for grp, e, case, avant in self.cases:
            if case.get_active() != avant:
                g = res.setdefault(grp["name"], (grp, [], []))
                (g[1] if case.get_active() else g[2]).append(e)
        return res

    @staticmethod
    def libelle(e):
        return NOMS.get(e, (e[8:] if e.startswith("flatpak:") else e, ""))[0]

    def maj_resume(self):
        ch = self.changements().values()
        plus = sum(len(c[1]) for c in ch)
        moins = sum(len(c[2]) for c in ch)
        morceaux = (([_("{plus} à installer").format(plus=plus)] if plus else []) +
                    ([_("{moins} à retirer").format(moins=moins)] if moins else []))
        self.resume.set_title(", ".join(morceaux) if morceaux else _("Aucune modification"))
        actif = bool(morceaux) and not self.occupe
        self.btn_appliquer.set_sensitive(actif)
        self.btn_annuler.set_sensitive(actif)

    def annuler_choix(self):
        for _g, _e, case, avant in self.cases:
            case.set_active(avant)

    def preparer(self):
        """Avant de retirer quoi que ce soit : simulation zypper (dépendances qui partiraient avec)."""
        if self.occupe:
            return
        ch = list(self.changements().values())
        a_simuler = [c for c in ch if c[2]]
        if not a_simuler:
            self.confirmer(ch, [])
            return
        self.occupe = True
        self.maj_resume()
        self.resume.set_title(_("Vérification de ce qui serait retiré… (mot de passe demandé)"))
        retires = []

        def suivant(i):
            if i == len(a_simuler):
                self.occupe = False
                self.maj_resume()
                self.confirmer(ch, retires)
                return
            grp, _plus, moins = a_simuler[i]
            try:
                p = Gio.Subprocess.new(["pkexec", AIDE_GROUPES, "simuler", grp["name"], *["-" + e for e in moins]],
                                       Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
            except GLib.Error as e:
                self.occupe = False
                self.maj_resume()
                self.toast(e.message)
                return

            def fini(proc, res):
                ok, out, _err = proc.communicate_utf8_finish(res)
                code = proc.get_exit_status()
                if code != 0:
                    # sans simulation, impossible d'annoncer ce qui partirait avec : on ne va pas plus loin
                    self.occupe = False
                    self.maj_resume()
                    if code in (126, 127):
                        self.toast(_("Annulé (mot de passe non fourni)"))
                    else:
                        erreur = [l for l in (out or "").splitlines() if l.strip()]
                        d = Adw.AlertDialog(heading=_("Vérification impossible"),
                                            body=_("Impossible de savoir ce qui serait retiré ; rien n'a été modifié. "
                                                   "Réessayez dans un moment.\n\n") + (erreur[-1] if erreur else ""))
                        d.add_response("ok", _("Fermer"))
                        d.present(self)
                    return
                retires.extend(l[7:] for l in (out or "").splitlines() if l.startswith("RETIRE "))
                suivant(i + 1)
            p.communicate_utf8_async(None, None, fini)
        suivant(0)

    def confirmer(self, ch, retires):
        plus = [self.libelle(e) for c in ch for e in c[1]]
        moins = [self.libelle(e) for c in ch for e in c[2]]
        # paquets réels des éléments décochés (python3-pip → python313-pip…) : le reste part par dépendance
        choisis = set(e for c in ch for e in c[2] if e.startswith("flatpak:"))
        choisis |= {n for c in ch for e in c[2] if not e.startswith("flatpak:")
                    for n in sortie(["rpm", "-q", "--whatprovides", "--qf", "%{NAME}\n", e]).split()}
        en_plus = [p for p in retires if p not in choisis]
        corps = []
        if plus:
            corps.append(_("À installer : {liste}").format(liste=", ".join(plus)))
        if moins:
            corps.append(_("À retirer : {liste}").format(liste=", ".join(moins)))
        if en_plus:
            corps.append(_("⚠ Retirés aussi, car ils en dépendent : {liste}").format(liste=", ".join(en_plus)))
        if plus:
            corps.append(_("L'installation peut prendre plusieurs minutes."))
        d = Adw.AlertDialog(heading=_("Appliquer les modifications ?"), body="\n\n".join(corps))
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Appliquer"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.DESTRUCTIVE if en_plus
                                  else Adw.ResponseAppearance.SUGGESTED)
        d.set_default_response("annuler" if en_plus else "ok")
        d.connect("response", lambda _d, rep: rep == "ok" and self.appliquer(ch))
        d.present(self)

    def appliquer(self, ch):
        self.occupe = True
        self.maj_resume()
        self.journal_groupe.set_visible(True)
        self.journal_groupe.set_title(_("Modification des logiciels"))
        self.etape.set_label(_("Démarrage… (mot de passe demandé)"))
        self.texte.get_buffer().set_text("")
        self.barre.pulse()
        self.pulsation = GLib.timeout_add(150, lambda: (self.barre.pulse(), True)[1])
        self.file = list(ch)
        self.codes = []
        self.etape_suivante()

    def etape_suivante(self):
        if not self.file:
            self.fin_installation(max(self.codes or [0]))
            return
        grp, plus, moins = self.file.pop(0)
        cmd = ["pkexec", AIDE_GROUPES, "appliquer", grp["name"], *["-" + e for e in moins], *["+" + e for e in plus]]
        try:
            proc = Gio.Subprocess.new(cmd, Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            self.fin_installation(1, e.message)
            return
        flux = Gio.DataInputStream.new(proc.get_stdout_pipe())
        self.lire_ligne(flux, proc)

    def lire_ligne(self, flux, proc):
        def recu(f, res):
            try:
                ligne, _n = f.read_line_finish_utf8(res)
            except GLib.Error:
                ligne = None
            if ligne is None:
                def fini(p, r):
                    p.wait_finish(r)
                    code = p.get_exit_status()
                    if code in (126, 127):   # mot de passe refusé : on s'arrête là
                        self.file = []
                    self.codes.append(code)
                    self.etape_suivante()
                proc.wait_async(None, fini)
                return
            buf = self.texte.get_buffer()
            buf.insert(buf.get_end_iter(), ligne + "\n")
            self.texte.scroll_to_iter(buf.get_end_iter(), 0, False, 0, 0)
            if ligne.startswith("==> "):
                self.etape.set_label(ligne[4:])
            m = PROGRES.match(ligne)
            if m and int(m.group(2)):
                # compteur de zypper « (12/229) Installing: … » : vraie progression
                if getattr(self, "pulsation", None):
                    GLib.source_remove(self.pulsation)
                    self.pulsation = None
                self.barre.set_fraction(int(m.group(1)) / int(m.group(2)))
            f.read_line_async(GLib.PRIORITY_DEFAULT, None, recu)
        flux.read_line_async(GLib.PRIORITY_DEFAULT, None, recu)

    def fin_installation(self, code, erreur=""):
        if getattr(self, "pulsation", None):
            GLib.source_remove(self.pulsation)
            self.pulsation = None
        self.occupe = False
        if code == 0:
            etape = _("Modifications appliquées.")
            self.toast(_("Logiciels mis à jour"))
        elif code in (126, 127):
            etape = _("Annulé (mot de passe non fourni).")
        else:
            etape = _("Terminé avec des erreurs (code {code}) — voir le détail ci-dessous. {erreur}").format(
                code=code, erreur=erreur)
        # cases recalculées d'après ce qui est réellement installé, journal de l'opération gardé affiché
        texte = self.texte.get_buffer().get_property("text")
        self.construire_logiciels()
        self.journal_groupe.set_visible(True)
        self.journal_groupe.set_title(_("Modification des logiciels"))
        self.etape.set_label(etape)
        self.barre.set_fraction(1.0 if code == 0 else 0.0)
        self.texte.get_buffer().set_text(texte)

    # ---------- Sécurité ----------

    def construire_securite(self):
        page = self.page_securite
        self.vider(page)
        self.groupes_antivirus(page)
        pf = sortie(["systemctl", "is-active", "firewalld"]) == "active"
        g = Adw.PreferencesGroup(title=_("Pare-feu"),
                                 description=_("Ce que les autres appareils du réseau peuvent joindre sur cet "
                                               "ordinateur. Les connexions sortantes (navigation, VPN, jeux en ligne) "
                                               "ne sont pas concernées. À garder fermé sur un réseau public (gare, "
                                               "café, hôtel)."))
        if not pf:
            g.add(self.ligne(_("Pare-feu"), _("Inactif : aucune protection des connexions entrantes"),
                             "network-wired-symbolic", False))
            self.ajouter(page, g)
        else:
            # lecture de la configuration en cours : autorisée sans mot de passe pour la session locale
            services = sortie(["firewall-cmd", "--list-services"]).split()
            for noms, titre, info, icone in SERVICES_PF:
                r = Adw.SwitchRow(title=titre, subtitle=info)
                r.add_prefix(Gtk.Image(icon_name=icone))
                r.set_active(all(x in services for x in noms))
                r.connect("notify::active", lambda s, _p, noms=noms, titre=titre: self.regler_interrupteur(
                    s, [AIDE_PAREFEU, "service", *["+" + x for x in noms]],
                    [AIDE_PAREFEU, "service", *["-" + x for x in noms]],
                    _("{titre} : autorisé").format(titre=titre), _("{titre} : bloqué").format(titre=titre),
                    _("Pare-feu non modifié")))
                g.add(r)
            connus = {x for noms, *_r in SERVICES_PF for x in noms}
            autres = [x for x in services if x not in connus]
            if autres:
                g.add(self.ligne(_("Autres services autorisés"), ", ".join(autres) +
                                 _("\n(dhcpv6-client : adresse IPv6 de la box ; mdns : imprimantes réseau)"),
                                 "emblem-system-symbolic"))
            self.ajouter(page, g)

            g = Adw.PreferencesGroup(title=_("Ports ouverts"))
            for p in sortie(["firewall-cmd", "--list-ports"]).split():
                num, proto = p.split("/")
                r = self.ligne(_("Port {num}").format(num=num), proto.upper(), "network-transmit-receive-symbolic")
                r.add_suffix(self.bouton(_("Fermer"), lambda p=p: self.aide_racine(
                    [AIDE_PAREFEU, "port", "-" + p], _("Port {p} fermé").format(p=p), _("Pare-feu non modifié"),
                    self.construire_securite)))
                g.add(r)
            entree = Adw.EntryRow(title=_("Ouvrir un port (ex. 8384, ou une plage 6000-6010)"))
            entree.set_input_purpose(Gtk.InputPurpose.DIGITS)
            proto = Gtk.DropDown.new_from_strings(["TCP", "UDP"])
            proto.set_valign(Gtk.Align.CENTER)
            entree.add_suffix(proto)
            entree.add_suffix(self.bouton(_("Ouvrir"), lambda: self.ouvrir_port(entree, proto), "suggested-action"))
            g.add(entree)
            r = Adw.ActionRow(title=_("Réglages avancés"),
                              subtitle=_("firewall-config : zones, services personnalisés, règles détaillées"))
            r.add_prefix(Gtk.Image(icon_name="preferences-system-symbolic"))
            r.add_suffix(self.bouton(_("Ouvrir"), lambda: self.lancer_appli("firewall-config.desktop",
                                                                         ["firewall-config"])))
            g.add(r)
            self.ajouter(page, g)

        g = Adw.PreferencesGroup(title=_("Confidentialité"))
        if any(os.path.exists(f"/sys/class/net/{n}/wireless") for n in os.listdir("/sys/class/net")):
            mac = Adw.SwitchRow(title=_("Adresse MAC aléatoire (wifi)"),
                                subtitle=_("Chaque réseau wifi voit une adresse différente, toujours la même pour ce "
                                           "réseau : plus difficile de suivre cet ordinateur d'un lieu à l'autre. "
                                           "Le wifi se reconnecte (quelques secondes)."))
            mac.add_prefix(Gtk.Image(icon_name="network-wireless-symbolic"))
            mac.set_active(os.path.exists(MAC))
            mac.connect("notify::active", lambda s, _p: self.regler_interrupteur(
                s, [AIDE_MAC, "oui"], [AIDE_MAC, "non"], _("Adresse MAC aléatoire activée"),
                _("Adresse MAC réelle rétablie"), _("Réglage réseau non modifié")))
            g.add(mac)
        else:
            g.add(self.ligne(_("Adresse MAC aléatoire (wifi)"), _("Aucune carte wifi détectée"),
                             "network-wireless-symbolic"))
        self.ajouter(page, g)
        self.groupe_camera_micro(page)

    # ----- caméra et micro (1.15.0) -----

    def groupe_camera_micro(self, page):
        g = Adw.PreferencesGroup(
            title=_("Caméra et micro"),
            description=_("Couper la caméra ou le micro pour toutes les applications, quelle que soit leur "
                          "origine. Une icône apparaît déjà en haut de l'écran quand l'un d'eux est utilisé."))
        coupee = os.path.exists(CAMERA_COUPEE)
        presentes = cameras()
        if presentes or coupee:
            r = Adw.SwitchRow(title=_("Caméra"),
                              subtitle=(_("Coupée : aucune application ne peut l'utiliser (pilote retiré)") if coupee
                                        else _("Autorisée : {noms}").format(noms=", ".join(presentes))))
            r.add_prefix(Gtk.Image(icon_name="camera-disabled-symbolic" if coupee else "camera-web-symbolic"))
            r.set_active(not coupee)
            r.connect("notify::active", lambda sw, _p: self.regler_interrupteur(
                sw, [AIDE_CAMERA, "oui"], [AIDE_CAMERA, "non"], _("Caméra rétablie"), _("Caméra coupée"),
                _("Caméra non modifiée"), self.construire_securite))
            g.add(r)
        else:
            g.add(self.ligne(_("Caméra"), _("Aucune caméra détectée"), "camera-web-symbolic"))
        if os.path.exists(MICRO) and shutil.which("pactl"):
            micro_coupe = sortie([MICRO, "etat"]) == "coupe"
            r = Adw.SwitchRow(title=_("Micro"),
                              subtitle=_("Coupé : toutes les entrées son sont muettes, même un casque branché "
                                         "ensuite, et à chaque ouverture de session. Ne protège pas d'un programme "
                                         "malveillant qui aurait les droits administrateur.") if micro_coupe else
                              _("Autorisé"))
            r.add_prefix(Gtk.Image(icon_name="microphone-disabled-symbolic" if micro_coupe
                                   else "audio-input-microphone-symbolic"))
            r.set_active(not micro_coupe)

            def micro(sw, _p):
                actif = sw.get_active()
                subprocess.run([MICRO, "retablir" if actif else "couper"], timeout=20)
                self.toast(_("Micro rétabli") if actif else _("Micro coupé"))
                GLib.timeout_add(500, lambda: self.construire_securite() and False)
            r.connect("notify::active", micro)
            g.add(r)
        self.ajouter(page, g)

    def ouvrir_port(self, entree, proto):
        texte = entree.get_text().strip().replace(" ", "")
        m = re.fullmatch(r"(\d{1,5})(?:-(\d{1,5}))?", texte)
        if not m or not all(1 <= int(x) <= 65535 for x in m.groups() if x) or \
                (m.group(2) and int(m.group(1)) >= int(m.group(2))):
            self.toast(_("Numéro de port invalide (1 à 65535, ou une plage comme 6000-6010)"))
            return
        p = f"{texte}/{['tcp', 'udp'][proto.get_selected()]}"
        self.aide_racine([AIDE_PAREFEU, "port", "+" + p], _("Port {p} ouvert").format(p=p), _("Pare-feu non modifié"),
                         self.construire_securite)

    def aide_racine(self, cmd, si_ok, si_echec, apres=None):
        """Aide pkexec sans interrupteur : message à la fin, puis apres() (souvent : reconstruire la page)."""
        try:
            p = Gio.Subprocess.new(["pkexec", *cmd], Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            self.toast(e.message)
            return

        def fini(proc, res):
            _ok, out, _err = proc.communicate_utf8_finish(res)
            code = proc.get_exit_status()
            if code == 0:
                self.toast(si_ok)
            elif code in (126, 127):
                self.toast(_("Annulé (mot de passe non fourni)"))
            else:
                lignes = [l for l in (out or "").splitlines() if l.strip()]
                self.toast(si_echec + (" : " + lignes[-1] if lignes else ""))
            if apres:
                apres()
        p.communicate_utf8_async(None, None, fini)

    # ----- antivirus -----

    def groupes_antivirus(self, page):
        g = Adw.PreferencesGroup(title=_("Antivirus (ClamAV)"),
                                 description=_("Recherche les virus connus, surtout utile pour des fichiers venus de "
                                               "Windows (clé USB, pièces jointes, téléchargements). Analyse à la "
                                               "demande : rien ne tourne en permanence."))
        self.ajouter(page, g)
        if not os.path.exists(CLAMSCAN):
            g.add(self.ligne("ClamAV", _("Non installé"), "dialog-warning-symbolic", False))
            return
        base = date_base_virus()
        if self.av_maj:
            texte = _("Téléchargement en cours… (quelques minutes la première fois)")
        elif base:
            # xgettext:no-python-format
            texte = _("Mise à jour le {date}").format(date=time.strftime(_("%d/%m/%Y à %H:%M"), time.localtime(base)))
        else:
            texte = _("Pas encore téléchargée : ≈ 110 Mo la première fois, ensuite de petites mises à jour "
                      "automatiques")
        r = self.ligne(_("Base de virus"), texte, "software-update-available-symbolic",
                       None if self.av_maj else bool(base) and time.time() - base < 8 * 86400)
        b = self.bouton(_("Mettre à jour") if base else _("Télécharger"), self.maj_antivirus,
                        None if base else "suggested-action")
        b.set_sensitive(not self.av_maj and self.av is None)
        r.add_suffix(b)
        g.add(r)
        if not base:
            return

        if self.av:
            r = Adw.ActionRow(title=_("Analyse en cours : {titre}").format(titre=self.av["titre"]))
            r.add_prefix(Gtk.Spinner(spinning=True))
            self.av_ligne = r
            self.maj_progression()
            r.add_suffix(self.bouton(_("Arrêter"), self.arreter_analyse, "destructive-action"))
            g.add(r)
        else:
            for titre, info, icone, rappel in [
                    (_("Dossier personnel"), _("Documents, téléchargements… Sans mot de passe."), "user-home-symbolic",
                     lambda: self.analyser(_("dossier personnel"), [os.path.expanduser("~")])),
                    (_("Système complet"), _("Tout le disque : long (souvent plus d'une heure). Mot de passe demandé."),
                     "drive-harddisk-symbolic", lambda: self.analyser(_("système complet"), None))]:
                r = self.ligne(titre, info, icone)
                r.add_suffix(self.bouton(_("Analyser"), rappel))
                g.add(r)
            amovibles = supports_amovibles()
            for nom, chemin in amovibles:
                r = self.ligne(_("Clé USB ou disque externe « {nom} »").format(nom=nom), chemin, "media-removable-symbolic")
                r.add_suffix(self.bouton(_("Analyser"), lambda c=chemin, n=nom: self.analyser(f"« {n} »", [c]),
                                         "suggested-action"))
                g.add(r)
            if not amovibles:
                g.add(self.ligne(_("Clé USB"), _("Branchez une clé : elle apparaît ici, prête à être analysée"),
                                 "media-removable-symbolic"))

        res = self.av_resultat
        if res:
            duree = (_("{n} s").format(n=round(res["duree"])) if res["duree"] < 90
                     else _("{n} min").format(n=round(res["duree"] / 60)))
            g = Adw.PreferencesGroup(title=_("Résultat : {titre}").format(titre=res["titre"]),
                                     description=_("{n} fichiers analysés en {duree}").format(n=res["n"], duree=duree)
                                                 + (_(" — analyse arrêtée avant la fin") if res["arret"] else ""))
            self.ajouter(page, g)
            if res.get("isoles"):
                g.add(self.ligne(_("{n} fichier(s) mis en quarantaine").format(n=res["isoles"]),
                                 _("Voir la liste « Quarantaine »"),
                                 "security-high-symbolic", True))
            elif not res["trouves"]:
                g.add(self.ligne(_("Aucun virus trouvé"), _("Rien à faire"), "security-high-symbolic", True))
            else:
                for chemin, menace in res["trouves"]:
                    g.add(self.ligne(menace, chemin, "dialog-warning-symbolic", False))
                r = Adw.ActionRow(title=_("Mettre en quarantaine ({n})").format(n=len(res["trouves"])),
                                  subtitle=_("Fichiers retirés de leur dossier et rendus inutilisables, restaurables "
                                             "plus tard. Mot de passe demandé."))
                r.add_suffix(self.bouton(_("Quarantaine"), self.mettre_en_quarantaine, "destructive-action"))
                g.add(r)

        q = quarantaine()
        if q:
            g = Adw.PreferencesGroup(title=_("Quarantaine"))
            self.ajouter(page, g)
            for e in sorted(q, key=lambda x: -x["date"]):
                r = self.ligne(e["chemin"], f"{e['menace']} — {time.strftime('%d/%m/%Y', time.localtime(e['date']))}",
                               "action-unavailable-symbolic")
                r.add_suffix(self.bouton(_("Restaurer"), lambda e=e: self.confirmer_quarantaine("restaurer", e)))
                r.add_suffix(self.bouton(_("Supprimer"), lambda e=e: self.confirmer_quarantaine("supprimer", e),
                                         "destructive-action"))
                g.add(r)

    def maj_antivirus(self):
        self.av_maj = True
        self.construire_securite()

        def apres():
            self.av_maj = False
            self.construire_securite()
        self.aide_racine([AIDE_ANTIVIRUS, "maj"], _("Base de virus à jour"),
                         _("Mise à jour impossible (connexion internet ?)"), apres)

    def analyser(self, titre, chemins):
        # en utilisateur pour le dossier personnel et les clés ; système complet : aide pkexec
        if chemins is None:
            cmd = ["pkexec", AIDE_ANTIVIRUS, "analyser"]
        else:
            cmd = ["nice", "-n", "10", CLAMSCAN, "-r", "--stdout", "--no-summary",
                   "--exclude-dir=^" + re.escape(os.path.expanduser("~/.cache")) + "/", *chemins]
        try:
            proc = Gio.Subprocess.new(cmd, Gio.SubprocessFlags.STDIN_PIPE | Gio.SubprocessFlags.STDOUT_PIPE
                                      | Gio.SubprocessFlags.STDERR_SILENCE)
        except GLib.Error as e:
            self.toast(e.message)
            return
        self.av = {"proc": proc, "titre": titre, "n": 0, "trouves": [], "debut": time.time(), "arret": False,
                   "racine": chemins is None, "dernier": ""}
        self.av_resultat = None
        self.construire_securite()
        flux = Gio.DataInputStream.new(proc.get_stdout_pipe())

        def recu(f, res):
            try:
                ligne, _n = f.read_line_finish_utf8(res)
            except GLib.Error:
                ligne = None
            if ligne is None:
                proc.wait_async(None, lambda p, r: (p.wait_finish(r), self.fin_analyse(p.get_exit_status())))
                return
            if ligne.endswith(" FOUND") and ": " in ligne:
                chemin, menace = ligne[:-6].rsplit(": ", 1)
                self.av["trouves"].append((chemin, menace))
                self.av["n"] += 1
            elif ": " in ligne:
                self.av["n"] += 1
                self.av["dernier"] = ligne.rsplit(": ", 1)[0]
            f.read_line_async(GLib.PRIORITY_DEFAULT, None, recu)
        flux.read_line_async(GLib.PRIORITY_DEFAULT, None, recu)
        self.av_minuteur = GLib.timeout_add(500, self.maj_progression)

    def maj_progression(self):
        if not self.av:
            return False
        a = self.av
        if a["n"] == 0:
            texte = _("Chargement de la base de virus… (jusqu'à une minute)")
        else:
            texte = _("{n} fichiers analysés, {virus} virus trouvé(s)\n{fichier}").format(
                n=a["n"], virus=len(a["trouves"]), fichier=a["dernier"][-90:])
        if getattr(self, "av_ligne", None):
            self.av_ligne.set_subtitle(texte)
        return True

    def arreter_analyse(self):
        if not self.av:
            return
        self.av["arret"] = True
        if self.av["racine"]:
            # processus root : l'aide s'arrête quand son entrée standard se ferme
            self.av["proc"].get_stdin_pipe().close()
        else:
            self.av["proc"].send_signal(15)

    def fin_analyse(self, code):
        a = self.av
        if getattr(self, "av_minuteur", None):
            GLib.source_remove(self.av_minuteur)
            self.av_minuteur = None
        self.av = None
        if a["racine"] and code in (126, 127):
            self.toast(_("Annulé (mot de passe non fourni)"))
        else:
            self.av_resultat = {"titre": a["titre"], "n": a["n"], "trouves": a["trouves"], "arret": a["arret"],
                                "duree": time.time() - a["debut"]}
            if a["trouves"]:
                self.toast(_("{n} virus trouvé(s) : voir le résultat").format(n=len(a["trouves"])))
            elif not a["arret"]:
                self.toast(_("Analyse terminée : aucun virus trouvé"))
        self.construire_securite()

    def mettre_en_quarantaine(self):
        res = self.av_resultat
        args = [x for c, m in res["trouves"] for x in (c, m)]

        def apres():
            restants = {e["chemin"] for e in quarantaine()}
            avant = len(res["trouves"])
            res["trouves"] = [(c, m) for c, m in res["trouves"] if os.path.realpath(c) not in restants]
            res["isoles"] = res.get("isoles", 0) + avant - len(res["trouves"])
            self.construire_securite()
        self.aide_racine([AIDE_ANTIVIRUS, "quarantaine", *args], _("Fichiers mis en quarantaine"),
                         _("Quarantaine incomplète"), apres)

    def confirmer_quarantaine(self, action, e):
        if action == "restaurer":
            d = Adw.AlertDialog(heading=_("Restaurer ce fichier ?"),
                                body=_("{fichier}\n\nIl a été détecté comme « {menace} ». Ne le restaurez que si vous êtes "
                                       "sûr qu'il s'agit d'une fausse alerte.")
                                     .format(fichier=e["chemin"], menace=e["menace"]))
            d.add_response("non", _("Annuler"))
            d.add_response("oui", _("Restaurer"))
            d.set_response_appearance("oui", Adw.ResponseAppearance.DESTRUCTIVE)
        else:
            d = Adw.AlertDialog(heading=_("Supprimer définitivement ce fichier ?"), body=e["chemin"])
            d.add_response("non", _("Annuler"))
            d.add_response("oui", _("Supprimer"))
            d.set_response_appearance("oui", Adw.ResponseAppearance.DESTRUCTIVE)
        d.set_default_response("non")
        d.connect("response", lambda _d, rep: rep == "oui" and self.aide_racine(
            [AIDE_ANTIVIRUS, action, e["id"]], _("Fichier restauré") if action == "restaurer" else _("Fichier supprimé"),
            _("Opération impossible"), self.construire_securite))
        d.present(self)

    # ---------- Réseau ----------

    def construire_reseau(self):
        page = self.page_reseau
        self.vider(page)
        actives = connexions(actives=True)
        g = Adw.PreferencesGroup(title=_("Connexion actuelle"))
        self.ajouter(page, g)
        vues = 0
        for uuid, genre, dev, nom in actives:
            if genre not in GENRES_NM:
                continue
            vues += 1
            i = infos_appareil(dev)
            lignes = [_("Adresse IP : {adresse}").format(adresse=", ".join(i.get("IP4.ADDRESS", [])) or _("aucune"))]
            if i.get("IP4.GATEWAY"):
                lignes.append(_("Passerelle (box) : {adresse}").format(adresse=i["IP4.GATEWAY"][0]))
            if i.get("IP4.DNS"):
                lignes.append(_("DNS : {adresses}").format(adresses=", ".join(i["IP4.DNS"])))
            if i.get("GENERAL.HWADDR"):
                lignes.append(_("Adresse MAC : {adresse}").format(adresse=i["GENERAL.HWADDR"][0]))
            g.add(self.ligne(f"{GENRES_NM[genre][0]} « {nom} »", "\n".join(lignes), GENRES_NM[genre][1]))
        if not vues:
            g.add(self.ligne(_("Pas de connexion"), _("Ni câble ni wifi connecté"), "network-offline-symbolic", False))
        r = self.ligne(_("Adresse IP publique"), _("Adresse vue par les sites internet (celle de la box, ou du VPN s'il "
                                                   "est actif). Affichée sur demande : demande au service ipify.org."), "network-workgroup-symbolic")
        r.add_suffix(self.bouton(_("Afficher"), lambda r=r: self.ip_publique(r)))
        g.add(r)
        r = Adw.ActionRow(title=_("Paramètres réseau de GNOME"), subtitle=_("Wifi, VPN, proxy, mots de passe des réseaux"))
        r.add_prefix(Gtk.Image(icon_name="preferences-system-network-symbolic"))
        r.add_suffix(self.bouton(_("Ouvrir"), lambda: self.lancer_appli("gnome-network-panel.desktop",
                                                                     ["gnome-control-center", "network"])))
        g.add(r)

        g = Adw.PreferencesGroup(title=_("Adressage IP"),
                                 description=_("Automatique : la box donne l'adresse (recommandé). Adresse fixe : utile "
                                               "pour un serveur, un partage ou une redirection de ports ; choisissez une "
                                               "adresse hors de la plage distribuée par la box. La connexion est "
                                               "relancée (coupure de quelques secondes)."))
        self.ajouter(page, g)
        actifs = {u: d for u, _g, d, _n in actives}
        for uuid, genre, _dev, nom in connexions(actives=False):
            if genre in GENRES_NM:
                g.add(self.ligne_adressage(uuid, genre, nom, actifs.get(uuid)))

    def ligne_adressage(self, uuid, genre, nom, dev):
        c = reglages_connexion(uuid)
        fixe = c.get("ipv4.method") == "manual"
        adresse = (c.get("ipv4.addresses") or "").split(",")[0].strip()
        passerelle, dns = c.get("ipv4.gateway") or "", (c.get("ipv4.dns") or "").replace(",", " ")
        if not fixe and dev:
            # proposer l'adresse actuelle comme point de départ d'une adresse fixe
            i = infos_appareil(dev)
            adresse = (i.get("IP4.ADDRESS") or [""])[0]
            passerelle = (i.get("IP4.GATEWAY") or [""])[0]
        ip, _s, prefixe = adresse.partition("/")
        e = Adw.ExpanderRow(title=f"{GENRES_NM[genre][0]} « {nom} »",
                            subtitle=_("Adresse fixe : {adresse}").format(adresse=adresse) if fixe else _("Automatique (DHCP)"))
        e.add_prefix(Gtk.Image(icon_name=GENRES_NM[genre][1]))
        mode = Adw.ComboRow(title=_("Mode"), model=Gtk.StringList.new([_("Automatique (DHCP)"), _("Adresse fixe")]))
        mode.set_selected(1 if fixe else 0)
        champs = [Adw.EntryRow(title=_("Adresse IP (ex. 192.168.1.50)"), text=ip),
                  Adw.EntryRow(title=_("Masque (ex. 24 ou 255.255.255.0)"), text=prefixe or "24"),
                  Adw.EntryRow(title=_("Passerelle : l'adresse de la box (ex. 192.168.1.1)"), text=passerelle),
                  Adw.EntryRow(title=_("DNS (facultatif, séparés par des espaces)"), text=dns.strip())]

        def sensibles(*_a):
            for ch in champs:
                ch.set_sensitive(mode.get_selected() == 1)
        mode.connect("notify::selected", sensibles)
        sensibles()
        e.add_row(mode)
        for ch in champs:
            e.add_row(ch)
        r = Adw.ActionRow()
        r.add_suffix(self.bouton(_("Appliquer"), lambda: self.appliquer_adressage(uuid, mode, champs),
                                 "suggested-action"))
        e.add_row(r)
        return e

    def appliquer_adressage(self, uuid, mode, champs):
        if mode.get_selected() == 0:
            self.aide_racine([AIDE_RESEAU, "auto", uuid], _("Adressage automatique rétabli"), _("Réglage non modifié"),
                             self.reseau_relu)
            return
        ip, masque, passerelle, dns = (ch.get_text().strip() for ch in champs)
        try:
            prefixe = ipaddress.IPv4Network(f"0.0.0.0/{masque}").prefixlen
            iface = ipaddress.IPv4Interface(f"{ip}/{prefixe}")
            gw = ipaddress.IPv4Address(passerelle)
            serveurs = [str(ipaddress.ip_address(d)) for d in dns.replace(",", " ").split()]
        except ValueError:
            self.toast(_("Adresse, masque, passerelle ou DNS invalide"))
            return
        if gw not in iface.network or gw == iface.ip:
            self.toast(_("La passerelle doit être une autre adresse du réseau {network}").format(network=iface.network))
            return
        self.aide_racine([AIDE_RESEAU, "fixe", uuid, str(iface), str(gw), *serveurs], _("Adresse fixe appliquée"),
                         _("Réglage non modifié"), self.reseau_relu)

    def reseau_relu(self):
        # juste après la relance, l'adresse peut encore manquer (« aucune ») : relire 4 s plus tard
        self.construire_reseau()
        GLib.timeout_add_seconds(4, lambda: (self.construire_reseau(), False)[1])

    def ip_publique(self, ligne):
        ligne.set_subtitle(_("Recherche…"))

        def chercher():
            res = []
            for nom, url in (("IPv4", "https://api.ipify.org"), ("IPv6", "https://api6.ipify.org")):
                try:
                    with urllib.request.urlopen(url, timeout=8) as r:
                        res.append(f"{nom} : {r.read(64).decode().strip()}")
                except (OSError, ValueError):
                    pass
            GLib.idle_add(ligne.set_subtitle, "\n".join(res) or _("Introuvable (pas de connexion internet ?)"))
        threading.Thread(target=chercher, daemon=True).start()

    # ---------- Aide ----------

    # ---------- Système ----------

    def construire_systeme(self):
        page = self.page_systeme
        self.vider(page)
        etat = sortie([AIDE_PROFIL, "etat"]).split()
        actuel = etat[0] if etat and etat[0] in dict(PROFILS) else "equilibre"
        g = Adw.PreferencesGroup(title=_("Profil du système"),
                                 description=_("Toujours le même noyau, celui de Tumbleweed : seuls des réglages "
                                               "changent. Un instantané (snapshot) est pris avant chaque changement, "
                                               "pour pouvoir revenir en arrière."))
        premier = None
        for cle, (titre, info, icone) in PROFILS:
            r = Adw.ActionRow(title=titre, subtitle=info)
            r.add_prefix(Gtk.Image(icon_name=icone))
            choix = Gtk.CheckButton(valign=Gtk.Align.CENTER, active=cle == actuel)
            if premier:
                choix.set_group(premier)
            premier = premier or choix
            choix.connect("toggled", lambda c, cle=cle: c.get_active() and cle != actuel and self.changer_profil(cle))
            r.add_suffix(choix)
            r.set_activatable_widget(choix)
            g.add(r)
        self.ajouter(page, g)

        g = Adw.PreferencesGroup(title=_("État"))
        if "REDEMARRAGE" in etat:
            r = self.ligne(_("Redémarrage nécessaire"), _("Les options de démarrage du profil s'appliqueront au "
                                                          "prochain démarrage"), "system-reboot-symbolic", False)
            r.add_suffix(self.bouton(_("Redémarrer"), lambda: subprocess.Popen(
                ["gnome-session-quit", "--reboot"], start_new_session=True)))
            g.add(r)
        else:
            g.add(self.ligne(_("Profil en service"), dict(PROFILS)[actuel][0], "emblem-system-symbolic", True))
        if actuel == "jeux":
            actif = sortie(["systemctl", "is-active", "scx.service"]) == "active"
            g.add(self.ligne(_("Ordonnanceur de jeux (scx_lavd)"), _("En service") if actif else
                             _("Arrêté : voir le rapport de diagnostic (onglet Aide)"), "input-gaming-symbolic", actif))
        self.ajouter(page, g)
        self.groupe_mises_a_jour(page)
        self.groupe_disposition(page)
        self.groupe_demarrage(page)
        self.groupe_instantanes(page)
        self.groupe_reinitialiser(page)

    def changer_profil(self, cle):
        titre = dict(PROFILS)[cle][0]
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_PROFIL, "appliquer", cle],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            self.toast(e.message)
            self.construire_systeme()
            return
        self.page_systeme.set_sensitive(False)

        def fini(proc, res):
            _ok, out, _err = proc.communicate_utf8_finish(res)
            code = proc.get_exit_status()
            lignes = [l for l in (out or "").splitlines() if l.strip()]
            self.page_systeme.set_sensitive(True)
            if code == 0:
                self.toast(_("Profil {titre} appliqué : redémarrez pour terminer").format(titre=titre)
                           if "REDEMARRAGE" in lignes else _("Profil {titre} appliqué").format(titre=titre))
            elif code in (126, 127):
                self.toast(_("Annulé (mot de passe non fourni)"))
            else:
                erreurs = [l for l in lignes if l != "REDEMARRAGE"]
                self.toast(_("Profil {titre} : problème").format(titre=titre) + (" : " + erreurs[-1] if erreurs else ""))
            self.construire_systeme()
        p.communicate_utf8_async(None, None, fini)

    # ----- mises à jour prudentes, retour automatique (1.15.0, avec KemmOS-Update 1.8.0) -----

    def groupe_mises_a_jour(self, page):
        if not os.path.exists(PRUDENT):
            return      # KemmOS-Update plus ancien que la 1.8.0
        try:
            with open(ETAT_PRUDENT) as f:
                etat = json.load(f)
        except (OSError, ValueError):
            etat = {}
        actif = etat.get("actif", True)
        g = Adw.PreferencesGroup(
            title=_("Mises à jour"),
            description=_("Tumbleweed publie une nouvelle version presque chaque jour. En mode prudent, KemmOS "
                          "attend qu'une version ait au moins 3 jours : un défaut grave a le temps d'être repéré "
                          "(et évité) avant d'arriver chez vous. Les correctifs urgents d'openSUSE et les "
                          "applications KemmOS restent immédiats."))
        v = etat.get("version", "")
        if actif and v:
            info = _("Activé : version de Tumbleweed du {date}").format(date=f"{v[6:8]}/{v[4:6]}/{v[0:4]}")
        elif actif:
            info = _("Activé (pris en compte à la prochaine vérification des mises à jour)")
        else:
            info = _("Désactivé : toujours la toute dernière version de Tumbleweed")
        r = Adw.SwitchRow(title=_("Mises à jour prudentes"), subtitle=info)
        r.add_prefix(Gtk.Image(icon_name="security-medium-symbolic"))
        r.set_active(actif)
        langue = "--langue=" + LANGUE
        r.connect("notify::active", lambda sw, _p: self.regler_interrupteur(
            sw, [KEMMOS_UPDATE, "--prudent=oui", langue], [KEMMOS_UPDATE, "--prudent=non", langue],
            _("Mises à jour prudentes activées"), _("Mises à jour prudentes désactivées"),
            _("Réglage non modifié"), lambda: (self.verifier_maj(), self.construire_systeme())))
        g.add(r)
        if os.path.exists(RETOUR_AUTO):
            essais = ""
            for l in lire("/boot/grub2/grubenv").splitlines():
                if l.startswith("kemmos_essais="):
                    essais = l.split("=", 1)[1]
            texte = (_("Une mise à jour vient d'être faite : si les deux prochains démarrages échouent, l'ordinateur "
                       "reviendra seul à l'état d'avant la mise à jour.") if essais in ("1", "2", "0") else
                     _("Après chaque mise à jour faite par KemmOS-Update : si l'ordinateur ne démarre plus deux fois "
                       "de suite, il revient seul à l'état d'avant la mise à jour."))
            g.add(self.ligne(_("Retour automatique si le démarrage échoue"), texte, "document-revert-symbolic", True))
        self.ajouter(page, g)

    # ----- disposition KemmOS 1.2 (1.11.0) -----

    @staticmethod
    def disposition_a_jour():
        favoris = Gio.Settings.new("org.gnome.shell").get_strv("favorite-apps")
        dossiers = Gio.Settings.new("org.gnome.desktop.app-folders").get_strv("folder-children")
        defaut = Gio.AppInfo.get_default_for_type(TYPES_APPS[0], False)
        return (all(a in favoris for a in DOCK_KEMMOS) and DOCK_ANCIEN not in favoris
                and "kemmos-kemmos" in dossiers and defaut is not None and defaut.get_id() == DOCK_KEMMOS[1])

    def groupe_disposition(self, page):
        g = Adw.PreferencesGroup(
            title=_("Disposition KemmOS 1.2"),
            description=_("Pour un système installé avant la 1.2 : le Centre KemmOS et KemmOS-Apps dans le dock "
                          "(à la place de GNOME Logiciels), un dossier « KemmOS » et les dossiers en tête de "
                          "« Afficher les applications ». Vos autres icônes du dock ne bougent pas."))
        a_jour = self.disposition_a_jour()
        r = self.ligne(_("Dock et grille des applications"),
                       _("Déjà à la disposition KemmOS 1.2") if a_jour else _("Ancienne disposition"),
                       "view-app-grid-symbolic", a_jour)
        r.add_suffix(self.bouton(_("Réappliquer") if a_jour else _("Appliquer"), self.appliquer_disposition,
                                 None if a_jour else "suggested-action"))
        g.add(r)
        if paquets_installes(["gnome-software"]):
            r = self.ligne(_("GNOME Logiciels"), _("Remplacé par KemmOS-Apps : peut être retiré "
                                                   "(il ne reviendra pas avec les mises à jour)"), "system-software-install-symbolic")
            r.add_suffix(self.bouton(_("Retirer"), lambda: self.aide_racine(
                [AIDE_GNOME_LOGICIELS, "retirer"], _("GNOME Logiciels retiré"), _("GNOME Logiciels : retrait en échec"),
                self.construire_systeme), "destructive-action"))
            g.add(r)
        self.ajouter(page, g)

    def appliquer_disposition(self):
        # dock : Centre et KemmOS-Apps à la place de GNOME Logiciels (sinon avant l'installateur du live,
        # sinon à la fin), le reste dans l'ordre de l'utilisateur
        shell = Gio.Settings.new("org.gnome.shell")
        favoris = shell.get_strv("favorite-apps")
        manquants = [a for a in DOCK_KEMMOS if a not in favoris]
        if DOCK_ANCIEN in favoris:
            i = favoris.index(DOCK_ANCIEN)
            favoris[i:i + 1] = manquants
        elif "calamares.desktop" in favoris:
            i = favoris.index("calamares.desktop")
            favoris[i:i] = manquants
        else:
            favoris += manquants
        shell.set_strv("favorite-apps", favoris)
        # dossier « KemmOS » (nom fixe : kemmos-kemmos.directory n'existe que dans l'image 1.2)
        dossiers = Gio.Settings.new("org.gnome.desktop.app-folders")
        enfants = dossiers.get_strv("folder-children")
        if "kemmos-kemmos" not in enfants:
            dossiers.set_strv("folder-children", enfants + ["kemmos-kemmos"])
        d = Gio.Settings.new_with_path("org.gnome.desktop.app-folders.folder",
                                       "/org/gnome/desktop/app-folders/folders/kemmos-kemmos/")
        if not d.get_strv("apps"):
            d.set_string("name", "KemmOS")
            d.set_boolean("translate", False)
            d.set_strv("apps", DOSSIER_KEMMOS)
        # grille : dossiers en tête (disposition remise à zéro ; les applications gardent l'ordre de GNOME).
        # GNOME Shell réagit au nouveau dossier en réenregistrant SA disposition (gardée en mémoire), ce qui
        # écrasait celle-ci (vu en VM, 1.1 + 1.11.0) : écrite après 2 s, puis vérifiée 3 s plus tard et
        # réécrite si GNOME l'a encore remplacée (dossiers plus en tête)
        positions = {nom: GLib.Variant("a{sv}", {"position": GLib.Variant("i", i)})
                     for i, nom in enumerate(n for n in ORDRE_DOSSIERS if n in enfants + ["kemmos-kemmos"])}
        disposition = GLib.Variant("aa{sv}", [positions])

        def grille(verifier):
            pages = shell.get_value("app-picker-layout").unpack()
            premiere = pages[0] if pages else {}
            en_tete = all(premiere.get(n, {}).get("position") == i
                          for n, i in ((n, v.unpack()["position"]) for n, v in positions.items()))
            if not (verifier and en_tete):
                shell.set_value("app-picker-layout", disposition)
                Gio.Settings.sync()
            if not verifier:
                GLib.timeout_add(3000, grille, True)
            return False
        GLib.timeout_add(2000, grille, False)
        # fichiers .flatpakref et liens appstream:// : KemmOS-Apps (Warehouse les prenait sinon)
        try:
            info = DesktopAppInfo.new(DOCK_KEMMOS[1])
        except TypeError:
            info = None
        if info:
            for t in TYPES_APPS:
                try:
                    info.set_as_default_for_type(t)
                except GLib.Error:
                    pass
        Gio.Settings.sync()
        self.toast(_("Disposition KemmOS 1.2 appliquée"))
        self.construire_systeme()

    # ----- démarrage (1.9.0) -----

    def groupe_demarrage(self, page):
        g = Adw.PreferencesGroup(
            title=_("Démarrage"),
            description=_("Le système qui démarre tout seul quand l'ordinateur s'allume. Le menu de démarrage "
                          "reste affiché quelques secondes pour en choisir un autre."))
        attente = self.ligne(_("Lecture du menu de démarrage…"), None, "system-run-symbolic")
        g.add(attente)
        self.ajouter(page, g)
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_DEMARRAGE_LISTE],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE)
        except GLib.Error as e:
            attente.set_title(_("Menu de démarrage illisible"))
            attente.set_subtitle(e.message)
            return

        def fini(proc, res):
            _ok, out, err = proc.communicate_utf8_finish(res)
            if g.get_parent() is None:   # page reconstruite entre-temps
                return
            try:
                info = json.loads(out or "")
            except ValueError:
                attente.set_title(_("Menu de démarrage illisible"))
                attente.set_subtitle(((err or "").strip().splitlines() or [_("erreur inconnue")])[-1])
                return
            g.remove(attente)
            self.lignes_demarrage(g, info)
        p.communicate_utf8_async(None, None, fini)

    def lignes_demarrage(self, g, info):
        systemes = info["systemes"]
        ids = [s["id"] for s in systemes]
        delai = info["delai"] if info["delai"] in DELAIS_MENU else 5
        if len(systemes) > 1:
            choix = Adw.ComboRow(title=_("Système par défaut"),
                                 model=Gtk.StringList.new([s["titre"] for s in systemes]))
            choix.set_selected(ids.index(info["defaut"]) if info["defaut"] in ids else 0)
            choix.add_prefix(Gtk.Image(icon_name="computer-symbolic"))
            g.add(choix)
        else:
            choix = None
            g.add(self.ligne(_("Système par défaut"), (systemes[0]["titre"] if systemes else "KemmOS")
                             + _(" (aucun autre système trouvé sur l'ordinateur)"), "computer-symbolic"))
        attente = Adw.ComboRow(title=_("Attente du menu"),
                               model=Gtk.StringList.new([_("{d} secondes").format(d=d) for d in DELAIS_MENU]))
        attente.set_selected(DELAIS_MENU.index(delai))
        attente.add_prefix(Gtk.Image(icon_name="preferences-system-time-symbolic"))
        g.add(attente)
        souvenir = Adw.SwitchRow(title=_("Se souvenir du dernier système choisi"),
                                 subtitle=_("Démarrer sur le système choisi dans le menu la fois précédente"),
                                 active=info["souvenir"])
        souvenir.add_prefix(Gtk.Image(icon_name="document-open-recent-symbolic"))
        g.add(souvenir)
        if not systemes:
            return
        depart = (choix.get_selected() if choix else 0, attente.get_selected(), souvenir.get_active())
        appliquer = self.bouton(_("Appliquer"), lambda: self.regler_demarrage(
            ids[choix.get_selected() if choix else 0], DELAIS_MENU[attente.get_selected()], souvenir.get_active()),
            "suggested-action")
        appliquer.set_sensitive(False)
        g.set_header_suffix(appliquer)

        def modifie(*_a):
            appliquer.set_sensitive((choix.get_selected() if choix else 0, attente.get_selected(),
                                     souvenir.get_active()) != depart)
        for w, signal in ((choix, "notify::selected"), (attente, "notify::selected"), (souvenir, "notify::active")):
            if w:
                w.connect(signal, modifie)

    def regler_demarrage(self, ident, delai, souvenir):
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_DEMARRAGE, "regler", ident, str(delai), "1" if souvenir else "0"],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            self.toast(e.message)
            return
        self.page_systeme.set_sensitive(False)

        def fini(proc, res):
            _ok, out, _err = proc.communicate_utf8_finish(res)
            code = proc.get_exit_status()
            self.page_systeme.set_sensitive(True)
            if code == 0:
                self.toast(_("Démarrage réglé : pris en compte au prochain allumage"))
            elif code in (126, 127):
                self.toast(_("Annulé (mot de passe non fourni)"))
            else:
                lignes = [l for l in (out or "").splitlines() if l.strip()]
                self.toast(_("Démarrage : problème") + (" : " + lignes[-1] if lignes else ""))
            self.construire_systeme()
        p.communicate_utf8_async(None, None, fini)

    # ----- points de restauration (1.7.0) -----

    def groupe_instantanes(self, page):
        g = Adw.PreferencesGroup(
            title=_("Points de restauration"),
            description=_("Avant chaque mise à jour et chaque changement de profil, KemmOS garde une copie du "
                          "système (instantané). Si quelque chose ne va plus, redémarrez sur un état d'avant : "
                          "s'il vous convient, KemmOS propose de le garder. Vos fichiers personnels ne sont "
                          "jamais modifiés."))
        g.set_header_suffix(self.bouton(_("Créer"), self.creer_instantane))
        attente = self.ligne(_("Lecture de la liste…"), None, "document-open-recent-symbolic")
        g.add(attente)
        self.ajouter(page, g)
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_INSTANTANES_LISTE],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE)
        except GLib.Error as e:
            attente.set_title(_("Liste indisponible"))
            attente.set_subtitle(e.message)
            return

        def fini(proc, res):
            _ok, out, err = proc.communicate_utf8_finish(res)
            if g.get_parent() is None:   # page reconstruite entre-temps
                return
            try:
                liste = json.loads(out or "")
            except ValueError:
                attente.set_title(_("Liste indisponible"))
                attente.set_subtitle(((err or "").strip().splitlines() or [_("erreur inconnue")])[-1])
                return
            g.remove(attente)
            # le système en cours (instantané actif) n'est pas un état « d'avant »
            visibles = [i for i in reversed(liste) if not i["actif"]][:MAX_INSTANTANES]
            if not visibles:
                g.add(self.ligne(_("Aucun point de restauration"), _("Le premier sera pris à la prochaine mise à jour"),
                                 "document-open-recent-symbolic"))
            for i in visibles:
                titre = libelle_instantane(i)
                r = Adw.ActionRow(title=titre, subtitle=_("{date} · n° {n}").format(date=i["date"], n=i["numero"])
                                  + (_(" · conservé") if i["important"] else ""))
                r.add_prefix(Gtk.Image(icon_name="document-open-recent-symbolic"))
                if i["demarrable"]:
                    r.add_suffix(self.bouton(_("Démarrer dessus"), lambda i=i, t=titre: self.demarrer_instantane(i, t)))
                g.add(r)
        p.communicate_utf8_async(None, None, fini)

    def demarrer_instantane(self, i, titre):
        d = Adw.AlertDialog(
            heading=_("Redémarrer sur cet état ?"),
            body=_("« {titre} », {date}.\n\nL'ordinateur va redémarrer sur cet état, en lecture seule. Vérifiez que "
                   "tout fonctionne : une fenêtre proposera alors de le garder (« Restaurer et redémarrer »). Sinon, "
                   "redémarrez simplement : vous retrouverez le système actuel.\n\nEnregistrez votre travail avant "
                   "de continuer : les applications ouvertes seront fermées.").format(titre=titre, date=i["date"]))
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Redémarrer"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.SUGGESTED)
        d.set_default_response("annuler")
        d.connect("response", lambda _d, rep: rep == "ok" and self.aide_racine(
            [AIDE_INSTANTANES, "demarrer", str(i["numero"])], _("Redémarrage…"),
            _("Impossible de redémarrer sur cet état")))
        d.present(self)

    def creer_instantane(self):
        entree = Gtk.Entry(placeholder_text=_("Ex. : avant d'installer un pilote"), max_length=60,
                           activates_default=True)
        d = Adw.AlertDialog(heading=_("Créer un point de restauration"),
                            body=_("Une copie de l'état actuel du système, conservée jusqu'à ce que vous la "
                                   "supprimiez. Donnez-lui un nom pour la retrouver."))
        d.set_extra_child(entree)
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Créer"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.SUGGESTED)
        d.set_default_response("ok")
        d.connect("response", lambda _d, rep: rep == "ok" and self.aide_racine(
            [AIDE_INSTANTANES, "creer", entree.get_text().strip() or _("créé depuis le Centre")],
            _("Point de restauration créé"), _("Création impossible"), self.construire_systeme))
        d.present(self)

    # ----- réinitialiser KemmOS (1.16.0) -----

    def groupe_reinitialiser(self, page):
        g = Adw.PreferencesGroup(
            title=_("Réinitialiser KemmOS"),
            description=_("Comme « Réinitialiser ce PC » sous Windows, si KemmOS ne fonctionne plus bien ou avant "
                          "de donner l'ordinateur."))
        neuf = Adw.ActionRow(title=_("Remettre KemmOS à neuf"),
                             subtitle=_("Garder mes fichiers : le système revient tel qu'il était à "
                                        "l'installation."))
        neuf.add_prefix(Gtk.Image(icon_name="view-refresh-symbolic"))
        attente = Gtk.Spinner(spinning=True, valign=Gtk.Align.CENTER)
        neuf.add_suffix(attente)
        g.add(neuf)
        effacer = Adw.ActionRow(title=_("Tout effacer"),
                                subtitle=_("Pour donner ou vendre l'ordinateur : réinstaller KemmOS depuis une clé "
                                           "USB efface tout le disque."))
        effacer.add_prefix(Gtk.Image(icon_name="user-trash-symbolic"))
        effacer.add_suffix(self.bouton(_("Comment faire…"), self.expliquer_tout_effacer))
        g.add(effacer)
        cle = Adw.ActionRow(title=_("Préparer une clé USB KemmOS"),
                            subtitle=_("Télécharger KemmOS, vérifier sa signature et l'écrire sur une clé USB"),
                            activatable=True)
        cle.add_prefix(Gtk.Image(icon_name="drive-removable-media-symbolic"))
        cle.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
        cle.connect("activated", lambda _r: self.lancer_appli("org.kemmos.CleUSB.desktop", ["kemmos-cle-usb"]))
        g.add(cle)
        self.ajouter(page, g)
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_INSTANTANES_LISTE],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_PIPE)
        except GLib.Error:
            p = None

        def fini(proc, res):
            _ok, out, _err = proc.communicate_utf8_finish(res)
            if g.get_parent() is None:
                return
            try:
                liste = json.loads(out or "")
            except ValueError:
                liste = []
            neuf.remove(attente)
            # instantané pris par l'installateur (snapper-setup.sh), conservé : point de retour d'usine
            install = next((i for i in liste if i["description"] == "Installation KemmOS"), None)
            if install is None:
                neuf.set_subtitle(_("Indisponible : l'instantané de l'installation n'existe plus sur cet "
                                    "ordinateur. Réinstallez KemmOS avec une clé USB (vos fichiers seront effacés : "
                                    "sauvegardez-les d'abord)."))
                neuf.set_sensitive(False)
                return
            neuf.add_suffix(self.bouton(_("Réinitialiser…"), lambda: self.confirmer_reinitialiser(install)))
        if p is None:
            neuf.remove(attente)
            neuf.set_sensitive(False)
        else:
            p.communicate_utf8_async(None, None, fini)

    def confirmer_reinitialiser(self, install):
        d = Adw.AlertDialog(
            heading=_("Remettre KemmOS à neuf ?"),
            body=_("Le système revient tel qu'il était à l'installation, le {date}.\n\n"
                   "Gardés : vos fichiers et réglages personnels (dossier personnel), les comptes et leurs mots de "
                   "passe, le wifi, la langue, le clavier et l'heure, les applications Flatpak (KemmOS-Apps).\n\n"
                   "Perdus : les logiciels installés depuis (hors Flatpak) et les réglages du système faits depuis "
                   "(imprimantes, pare-feu, profil…). Une copie du système actuel est gardée dans les points de "
                   "restauration.\n\n"
                   "L'ordinateur redémarre deux fois, ce qui prend quelques minutes. Ensuite, faites les mises à "
                   "jour (KemmOS-Update) : le système date de l'installation.\n\n"
                   "Enregistrez votre travail avant de continuer.").format(date=install["date"].split(" ")[0]))
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Réinitialiser et redémarrer"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.DESTRUCTIVE)
        d.set_default_response("annuler")
        d.connect("response", lambda _d, rep: rep == "ok" and self.aide_racine(
            [AIDE_REINIT, "garder", str(install["numero"])], _("Redémarrage…"),
            _("Réinitialisation impossible")))
        d.present(self)

    def expliquer_tout_effacer(self):
        d = Adw.AlertDialog(
            heading=_("Tout effacer avant de donner ou de vendre"),
            body=_("Le plus sûr est de réinstaller KemmOS : tout le disque est effacé, avec un nouveau "
                   "chiffrement, et le nouveau propriétaire choisit lui-même son nom et son mot de passe.\n\n"
                   "1. Sauvegardez ce que vous voulez garder (application Sauvegardes, ou copie sur un disque externe).\n"
                   "2. Préparez une clé USB KemmOS (8 Go au moins).\n"
                   "3. Démarrez l'ordinateur sur la clé (touche du menu de démarrage : souvent F12, F11, F8 ou "
                   "Échap).\n"
                   "4. Dans l'installateur, choisissez « Effacer le disque ». Vous pouvez aussi éteindre "
                   "l'ordinateur à l'étape du compte et laisser le nouveau propriétaire faire l'installation."))
        d.add_response("fermer", _("Fermer"))
        d.add_response("cle", _("Préparer une clé USB KemmOS"))
        d.set_response_appearance("cle", Adw.ResponseAppearance.SUGGESTED)
        d.set_default_response("cle")
        d.connect("response", lambda _d, rep: rep == "cle" and self.lancer_appli("org.kemmos.CleUSB.desktop",
                                                                                ["kemmos-cle-usb"]))
        d.present(self)

    def construire_aide(self):
        page = self.page_aide
        g = Adw.PreferencesGroup(title=_("Guide KemmOS"))
        r = Adw.ActionRow(title=_("Ouvrir le guide"),
                          subtitle=_("Installation, mises à jour, pare-feu, VPN, conteneurs… Fonctionne sans "
                                     "internet (copie du wiki du site)."), activatable=True)
        r.add_prefix(Gtk.Image(icon_name="help-browser-symbolic"))
        r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
        r.connect("activated", lambda _r: self.ouvrir_guide())
        g.add(r)
        page.add(g)

        g = Adw.PreferencesGroup(title=_("Je viens de Windows"))
        r = Adw.ActionRow(title=_("Récupérer mes fichiers de Windows"),
                          subtitle=_("Documents, photos, musique et favoris d'un Windows installé sur cet "
                                     "ordinateur (BitLocker compris). Windows n'est pas modifié."), activatable=True)
        r.add_prefix(Gtk.Image(icon_name="folder-download-symbolic"))
        r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
        r.connect("activated", lambda _r: self.lancer_appli("org.kemmos.Windows.desktop", ["kemmos-windows"]))
        g.add(r)
        r = Adw.ActionRow(title=_("Équivalents des programmes Windows"),
                          subtitle=_("Word → LibreOffice, Paint → Pinta, Photos → Visionneuse…"), activatable=True)
        r.add_prefix(Gtk.Image(icon_name="view-list-symbolic"))
        r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
        r.connect("activated", lambda _r: subprocess.Popen(["kemmos-windows", "--equivalents"],
                                                           start_new_session=True))
        g.add(r)
        page.add(g)

        g = Adw.PreferencesGroup(
            title=_("Rapport de diagnostic"),
            description=_("Rassemble les informations utiles (versions, matériel, erreurs, sécurité) dans un "
                          "fichier texte à joindre à une demande d'aide. Adresses IP et MAC masquées, aucun "
                          "mot de passe. Le mot de passe est demandé pour inclure les journaux du système."))
        self.ligne_diag = Adw.ActionRow(title=_("Créer un rapport"), subtitle=_("Enregistré dans votre dossier personnel"))
        self.ligne_diag.add_prefix(Gtk.Image(icon_name="document-save-symbolic"))
        self.btn_diag = self.bouton(_("Créer"), self.diagnostic, "suggested-action")
        self.ligne_diag.add_suffix(self.btn_diag)
        g.add(self.ligne_diag)
        page.add(g)

        g = Adw.PreferencesGroup(title=_("Outils"))
        for titre, sous, icone, appli, secours in [
            (_("Mises à jour"), _("KemmOS-Update : icône dans la barre du haut"), "software-update-available-symbolic",
             "kemmos-update-tray.desktop", None),
            (_("Sauvegardes"), _("Déjà Dup : copie de vos fichiers sur un disque externe ou en ligne"),
             "drive-multidisk-symbolic", "org.gnome.DejaDup.desktop", None),
            (_("Logithèque"), _("KemmOS-Apps : installer d'autres applications (Flathub)"), "system-software-install-symbolic",
             "org.kemmos.Apps.desktop", ["kemmos-apps"]),
            (_("Énergie"), _("Profil d'énergie, veille, batterie"), "battery-symbolic",
             "gnome-power-panel.desktop", ["gnome-control-center", "power"]),
            (_("Tester mon ordinateur"), _("Affichage, Wi-Fi, son, disque, webcam… : ce qui fonctionne avec KemmOS"),
             "computer-symbolic", "org.kemmos.Compatibilite.desktop", ["kemmos-compatibilite"]),
            (_("Coffre-fort des papiers"), _("Dossier chiffré pour vos papiers importants, rappels avant l'expiration "
                                             "des documents"), "channel-secure-symbolic", "org.kemmos.Coffre.desktop",
             ["kemmos-coffre"]),
        ]:
            r = Adw.ActionRow(title=titre, subtitle=sous, activatable=True)
            r.add_prefix(Gtk.Image(icon_name=icone))
            r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
            r.connect("activated", lambda _r, a=appli, s=secours: self.lancer_appli(a, s))
            g.add(r)
        page.add(g)

        g = Adw.PreferencesGroup(title=_("Revenir en arrière"))
        g.add(self.ligne(_("Restaurer le système"),
                         _("Onglet Système, « Points de restauration » : redémarrer sur un état d'avant. Si "
                           "l'ordinateur ne démarre plus après une mise à jour, il y revient tout seul au troisième "
                           "essai ; sinon, au démarrage : menu GRUB « Start bootloader from a read-only snapshot », "
                           "puis choisir un instantané. KemmOS propose ensuite de le rendre définitif. Vos fichiers "
                           "personnels ne sont pas modifiés."), "document-revert-symbolic"))
        page.add(g)

        g = Adw.PreferencesGroup(title=_("Site de KemmOS"))
        r = Adw.ActionRow(title=URL, activatable=True)
        r.add_prefix(Gtk.Image(icon_name="web-browser-symbolic"))
        r.connect("activated", lambda _r: Gio.AppInfo.launch_default_for_uri(URL, None))
        g.add(r)
        page.add(g)

    def ouvrir_guide(self):
        if not os.path.exists(GUIDE):
            self.toast(_("Guide introuvable : réinstallez le paquet kemmos-centre"))
            return
        try:
            Gio.AppInfo.launch_default_for_uri(GLib.filename_to_uri(GUIDE), None)
        except GLib.Error as e:
            self.toast(_("Impossible d'ouvrir le guide : {message}").format(message=e.message))

    def diagnostic(self):
        self.btn_diag.set_sensitive(False)
        self.ligne_diag.set_subtitle(_("Création en cours… (mot de passe demandé)"))
        fichier = os.path.expanduser(f"~/kemmos-diag-{time.strftime('%Y-%m-%d_%H%M')}.txt")
        try:
            proc = Gio.Subprocess.new(["kemmos-diag", fichier], Gio.SubprocessFlags.STDOUT_SILENCE)
        except GLib.Error as e:
            self.ligne_diag.set_subtitle(_("Échec : {message}").format(message=e.message))
            self.btn_diag.set_sensitive(True)
            return

        def fini(p, res):
            p.wait_finish(res)
            self.btn_diag.set_sensitive(True)
            if os.path.exists(fichier):
                self.ligne_diag.set_subtitle(_("Enregistré : {fichier}").format(fichier=fichier))
                Gio.DBusProxy.new_for_bus(
                    Gio.BusType.SESSION, Gio.DBusProxyFlags.NONE, None, "org.freedesktop.FileManager1",
                    "/org/freedesktop/FileManager1", "org.freedesktop.FileManager1", None,
                    lambda _s, r: Gio.DBusProxy.new_for_bus_finish(r).call(
                        "ShowItems", GLib.Variant("(ass)", ([GLib.filename_to_uri(fichier)], "")),
                        Gio.DBusCallFlags.NONE, -1, None, None))
            else:
                self.ligne_diag.set_subtitle(_("Échec de la création du rapport"))
        proc.wait_async(None, fini)


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

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


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