#!/usr/bin/python3
# Tester mon ordinateur (Centre KemmOS 1.15.0) : avant d'installer KemmOS (session live) ou après, vérifie le
# matériel et donne un verdict simple par ligne — vert (fonctionne), orange (à savoir), rouge (problème).
# Rien n'est envoyé sur Internet. Tout se lit sans mot de passe (/sys, /proc, lsblk, journal du noyau si permis).
# « kemmos-compatibilite --texte » : rapport en texte (essais, forum).
# 1.16.0 : essais à faire soi-même — son (gauche puis droite, « Entendu ? »), aperçu de la caméra, niveau du micro,
# touches du clavier ; leurs résultats s'ajoutent au rapport.
import gettext
import os
import re
import subprocess
import sys


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
    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.Compatibilite"
SYS = os.environ.get("KEMMOS_SYS", "")   # préfixe de /sys et /proc pour les essais
OK, ATTENTION, PROBLEME, INFO = "ok", "attention", "probleme", "info"
GO = 1024 ** 3
# lecteurs d'empreintes courants (fabricants USB) : pris en charge selon le modèle
EMPREINTES = {"27c6": "Goodix", "06cb": "Synaptics", "138a": "Validity", "04f3": "Elan", "10a5": "FPC",
              "1c7a": "LighTuning", "2808": "Focaltech", "298d": "Next Biometrics"}


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


def lister(chemin):
    try:
        return sorted(os.listdir(SYS + chemin))
    except OSError:
        return []


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


def taille(n, decimale=False):
    t = f"{n / GO:.1f}" if decimale else f"{n / GO:.0f}"
    return t.replace(".", ",") + " Go" if LANGUE in ("fr", "br") else t + " GB"


# ---------- périphériques ----------

def pci():
    """[(adresse, classe « 0xCCSS », fabricant « 0x10de », pilote ou "")]"""
    res = []
    for d in lister("/sys/bus/pci/devices"):
        base = f"/sys/bus/pci/devices/{d}"
        pilote = os.path.basename(os.path.realpath(SYS + base + "/driver")) if os.path.exists(SYS + base + "/driver") else ""
        res.append((d, lire(base + "/class")[:6], lire(base + "/vendor"), pilote))
    return res


def nom_pci(adresse):
    champs = re.findall(r'"([^"]*)"', sortie(["lspci", "-mm", "-s", adresse]))
    return " ".join(champs[1:3]) if len(champs) >= 3 else adresse


def firmwares_manquants(journal):
    """Fichiers de firmware que le noyau n'a pas trouvés (journal du noyau, texte)."""
    vus = []
    for m in re.finditer(r"(?:Direct firmware load for (\S+) failed|firmware: failed to load (\S+))", journal):
        f = m.group(1) or m.group(2)
        if f not in vus:
            vus.append(f)
    return vus


def journal_noyau():
    """Journal du noyau de ce démarrage, "" si l'utilisateur n'a pas le droit de le lire."""
    return sortie(["journalctl", "-k", "-b", "-q", "--no-pager", "-o", "cat"], timeout=20)


def disques(lsblk):
    """Disques internes [(nom, octets, ssd, modèle)] d'après « lsblk -bdnP -o NAME,SIZE,RM,ROTA,TYPE,TRAN,MODEL »
    (clés USB, lecteurs, disques en mémoire écartés)."""
    res = []
    for ligne in lsblk.splitlines():
        c = dict(re.findall(r'(\w+)="([^"]*)"', ligne))
        if c.get("TYPE") != "disk" or c.get("RM") == "1" or c.get("TRAN") == "usb" \
                or re.match(r"(zram|loop|sr|ram)", c.get("NAME", "")):
            continue
        try:
            octets = int(c.get("SIZE", "0"))
        except ValueError:
            continue
        res.append((c["NAME"], octets, c.get("ROTA") == "0", c.get("MODEL", "").strip()))
    return res


def windows(lsblk_fs):
    """(windows présent, BitLocker) d'après « lsblk -nP -o FSTYPE,PARTLABEL,LABEL »."""
    win = bitlocker = False
    for ligne in lsblk_fs.splitlines():
        c = dict(re.findall(r'(\w+)="([^"]*)"', ligne))
        fs = c.get("FSTYPE", "").lower()
        if fs == "bitlocker":
            win = bitlocker = True
        elif fs == "ntfs" and "recovery" not in (c.get("PARTLABEL", "") + c.get("LABEL", "")).lower():
            win = True
    return win, bitlocker


def memoire(meminfo):
    m = re.search(r"^MemTotal:\s+(\d+) kB", meminfo, re.M)
    return int(m.group(1)) * 1024 if m else 0


def usb_ids():
    """{(fabricant, produit)} des périphériques USB."""
    res = set()
    for d in lister("/sys/bus/usb/devices"):
        v = lire(f"/sys/bus/usb/devices/{d}/idVendor")
        if v:
            res.add((v, lire(f"/sys/bus/usb/devices/{d}/idProduct")))
    return res


# ---------- vérifications : (catégorie, titre, niveau, texte) ----------

def verif_graphique(peripheriques):
    res = []
    cartes = [(a, f, p) for a, c, f, p in peripheriques if c.startswith("0x03")]
    for a, f, p in cartes:
        nom = nom_pci(a)
        if f == "0x10de":
            if p == "nvidia":
                res.append(("graphique", nom, OK, _("Pilote officiel NVIDIA actif")))
            else:
                res.append(("graphique", nom, ATTENTION,
                            _("Carte NVIDIA : fonctionne avec le pilote libre, mais pour les jeux et les "
                              "performances, cochez « NVIDIA drivers (RTX) » pendant l'installation (ou plus tard "
                              "dans le Centre KemmOS, onglet Logiciels).")))
        elif p in ("i915", "xe", "amdgpu", "radeon", "nouveau"):
            res.append(("graphique", nom, OK, _("Pilote chargé ({pilote}) : affichage et accélération 3D").format(pilote=p)))
        elif p:
            res.append(("graphique", nom, OK, _("Pilote chargé ({pilote})").format(pilote=p)))
        else:
            res.append(("graphique", nom, PROBLEME, _("Aucun pilote : affichage de base seulement, sans accélération")))
    if not cartes:
        res.append(("graphique", _("Carte graphique"), ATTENTION, _("Aucune carte graphique PCI détectée")))
    return res


def verif_reseau(peripheriques, firmwares, wifi_present, etat_nm):
    res = []
    for a, c, f, p in peripheriques:
        if not c.startswith("0x02"):
            continue
        genre = _("Wi-Fi") if c == "0x0280" else _("Réseau filaire")
        if p:
            res.append(("reseau", f"{genre} : {nom_pci(a)}", OK, _("Pilote chargé ({pilote})").format(pilote=p)))
        else:
            res.append(("reseau", f"{genre} : {nom_pci(a)}", PROBLEME,
                        _("Aucun pilote : cette carte ne fonctionnera pas. Un adaptateur Wi-Fi USB ou un câble "
                          "réseau permettent de s'en passer.")))
    if wifi_present and not any(c == "0x0280" for _a, c, _f, _p in peripheriques):
        res.append(("reseau", _("Wi-Fi (USB ou intégré)"), OK, _("Carte Wi-Fi reconnue")))
    pertinents = [f for f in firmwares if re.match(r"(iwlwifi|ath|rtw|rtl|brcm|mt7|mediatek|qca|intel/ibt|rtl_bt)", f)]
    if pertinents:
        res.append(("reseau", _("Firmware manquant"), ATTENTION,
                    _("Le noyau n'a pas trouvé : {liste}. Le Wi-Fi ou le Bluetooth peuvent ne pas fonctionner : "
                      "signalez-le avec un rapport de diagnostic.").format(liste=", ".join(pertinents[:4]))))
    if etat_nm.strip().startswith("connected") or etat_nm.strip().startswith("connecté"):
        res.append(("reseau", _("Internet"), OK, _("Connecté")))
    elif etat_nm.strip():
        res.append(("reseau", _("Internet"), INFO, _("Pas connecté pour l'instant (menu en haut à droite pour "
                                                     "choisir un réseau Wi-Fi)")))
    return res


def verif_son(peripheriques, cartes_alsa, sorties):
    res = []
    for a, c, f, p in peripheriques:
        if c == "0x0403" and not p:
            res.append(("son", nom_pci(a), PROBLEME, _("Aucun pilote : pas de son par cette carte")))
    if "no soundcards" in cartes_alsa or not cartes_alsa.strip():
        res.append(("son", _("Son"), PROBLEME, _("Aucune carte son reconnue")))
    elif sorties and all("auto_null" in l or "dummy" in l.lower() for l in sorties.splitlines() if l.strip()):
        res.append(("son", _("Son"), ATTENTION, _("Carte son reconnue, mais aucune sortie utilisable (haut-parleurs, "
                                                   "casque) : essayez de brancher un casque")))
    else:
        n = len(re.findall(r"^\s*\d+ \[", cartes_alsa, re.M))
        res.append(("son", _("Son"), OK, ngettext("{n} carte son reconnue", "{n} cartes son reconnues", n).format(n=n)))
    return res


def verif_demarrage(secure_boot, tpm_version):
    res = []
    if secure_boot is True:
        res.append(("demarrage", _("Démarrage sécurisé (Secure Boot)"), OK, _("Actif : KemmOS démarre avec")))
    elif secure_boot is False:
        res.append(("demarrage", _("Démarrage sécurisé (Secure Boot)"), INFO,
                    _("Désactivé : KemmOS fonctionne aussi, il peut être réactivé dans le BIOS/UEFI")))
    if tpm_version == "2":
        res.append(("demarrage", _("Puce de sécurité (TPM 2.0)"), OK, _("Présente")))
    elif tpm_version:
        res.append(("demarrage", _("Puce de sécurité (TPM {v})").format(v=tpm_version), INFO, _("Ancienne version")))
    return res


def verif_capacites(octets_ram, liste_disques, win, bitlocker):
    res = []
    if octets_ram:
        # mémoire vue par le système : moins que les barrettes (noyau, carte graphique intégrée qui en prend
        # jusqu'à 1 Go) — un PC de 4 Go en montre de 3 à 3,7 ; de 8 Go, environ 7,5
        ram = taille(octets_ram, decimale=True)
        if octets_ram < 2.5 * GO:
            res.append(("capacites", _("Mémoire vive"), PROBLEME,
                        _("{ram} : trop peu, KemmOS demande au moins 4 Go").format(ram=ram)))
        elif octets_ram < 6.5 * GO:
            res.append(("capacites", _("Mémoire vive"), ATTENTION,
                        _("{ram} : suffisant, 8 Go conseillés pour plusieurs applications ouvertes").format(ram=ram)))
        else:
            res.append(("capacites", _("Mémoire vive"), OK, ram))
    if not liste_disques:
        res.append(("capacites", _("Disque"), PROBLEME, _("Aucun disque interne détecté pour installer KemmOS "
                                                          "(contrôleur RAID ou Intel RST ? À désactiver dans le BIOS)")))
    else:
        nom, octets, ssd, modele = max(liste_disques, key=lambda d: d[1])
        texte = _("{taille} ({genre}{modele})").format(taille=taille(octets), genre=_("SSD") if ssd else _("disque dur"),
                                                       modele=", " + modele if modele else "")
        # mêmes seuils que le wiki (Configuration requise) : 25 Go minimum, 40 Go et plus conseillés
        if octets < 25 * GO:
            res.append(("capacites", _("Disque"), PROBLEME, texte + _(" : trop petit, 25 Go au minimum")))
        elif octets < 40 * GO:
            res.append(("capacites", _("Disque"), ATTENTION, texte + _(" : un peu juste, 40 Go conseillés")))
        else:
            res.append(("capacites", _("Disque"), OK, texte + ("" if ssd else _(" — un disque dur est plus lent qu'un SSD"))))
    if bitlocker:
        res.append(("capacites", _("Windows (BitLocker)"), ATTENTION,
                    _("Windows est présent et chiffré par BitLocker. Avant d'installer KemmOS à côté, notez la clé "
                      "de récupération BitLocker (compte Microsoft) : elle sera demandée par Windows.")))
    elif win:
        res.append(("capacites", _("Windows"), INFO, _("Windows est présent : KemmOS peut s'installer à côté "
                                                       "(choix au démarrage)")))
    return res


def verif_peripheriques(cameras, bluetooth, bt_bloque, ids_usb, batteries):
    res = []
    if cameras:
        res.append(("peripheriques", _("Webcam"), OK, ", ".join(cameras)))
    else:
        res.append(("peripheriques", _("Webcam"), INFO, _("Aucune webcam détectée")))
    if bt_bloque:
        res.append(("peripheriques", "Bluetooth", ATTENTION, _("Bloqué par un interrupteur, une touche Fn ou le BIOS")))
    elif bluetooth:
        res.append(("peripheriques", "Bluetooth", OK, _("Disponible")))
    else:
        res.append(("peripheriques", "Bluetooth", INFO, _("Aucun adaptateur détecté")))
    lecteurs = sorted({EMPREINTES[v] for v, _p in ids_usb if v in EMPREINTES})
    if lecteurs:
        res.append(("peripheriques", _("Lecteur d'empreintes"), ATTENTION,
                    _("{marque} : pris en charge selon le modèle ; sinon, le mot de passe reste possible").format(
                        marque=", ".join(lecteurs))))
    for nom, pct in batteries:
        if pct < 50:
            res.append(("peripheriques", _("Batterie ({nom})").format(nom=nom), ATTENTION,
                        _("{pct} % de sa capacité d'origine : autonomie réduite").format(pct=round(pct))))
        else:
            res.append(("peripheriques", _("Batterie ({nom})").format(nom=nom), OK,
                        _("{pct} % de sa capacité d'origine").format(pct=round(pct))))
    return res


def batteries():
    res = []
    for n in lister("/sys/class/power_supply"):
        b = f"/sys/class/power_supply/{n}"
        if lire(b + "/type") != "Battery":
            continue
        for plein, origine in (("energy_full", "energy_full_design"), ("charge_full", "charge_full_design")):
            try:
                res.append((n, min(100, 100 * int(lire(f"{b}/{plein}")) / int(lire(f"{b}/{origine}")))))
                break
            except (ValueError, ZeroDivisionError):
                continue
    return res


def secure_boot():
    try:
        with open(SYS + "/sys/firmware/efi/efivars/SecureBoot-8be4df61-93ca-11d2-aa0d-00e098032b8c", "rb") as f:
            return f.read()[-1] == 1
    except (OSError, IndexError):
        return None


def tout_verifier():
    peripheriques = pci()
    wifi = any(os.path.exists(f"{SYS}/sys/class/net/{n}/wireless") for n in lister("/sys/class/net"))
    bt = lister("/sys/class/bluetooth")
    bt_bloque = any(lire(f"/sys/class/rfkill/{r}/type") == "bluetooth" and lire(f"/sys/class/rfkill/{r}/hard") == "1"
                    for r in lister("/sys/class/rfkill"))
    cameras = sorted({lire(f"/sys/class/video4linux/{v}/name") for v in lister("/sys/class/video4linux")} - {""})
    return (verif_graphique(peripheriques)
            + verif_reseau(peripheriques, firmwares_manquants(journal_noyau()), wifi,
                           sortie(["nmcli", "-t", "-f", "STATE", "general"]))
            + verif_son(peripheriques, lire("/proc/asound/cards"), sortie(["pactl", "list", "short", "sinks"]))
            + verif_demarrage(secure_boot(), lire("/sys/class/tpm/tpm0/tpm_version_major"))
            + verif_capacites(memoire(lire("/proc/meminfo")),
                              disques(sortie(["lsblk", "-bdnP", "-o", "NAME,SIZE,RM,ROTA,TYPE,TRAN,MODEL"])),
                              *windows(sortie(["lsblk", "-nP", "-o", "FSTYPE,PARTLABEL,LABEL"])))
            + verif_peripheriques(cameras, bt, bt_bloque, usb_ids(), batteries()))


CATEGORIES = [("graphique", _("Affichage"), "video-display-symbolic"),
              ("reseau", _("Réseau et Internet"), "network-wireless-symbolic"),
              ("son", _("Son"), "audio-speakers-symbolic"),
              ("capacites", _("Mémoire, disque et Windows"), "drive-harddisk-symbolic"),
              ("demarrage", _("Démarrage et sécurité"), "channel-secure-symbolic"),
              ("peripheriques", _("Webcam, Bluetooth, batterie"), "camera-web-symbolic")]
SYMBOLES = {OK: "✔", ATTENTION: "⚠", PROBLEME: "✖", INFO: "ℹ"}


def bilan(resultats):
    if any(n == PROBLEME for _c, _t, n, _x in resultats):
        return PROBLEME, _("Un ou plusieurs problèmes : KemmOS risque de mal fonctionner sur cet ordinateur.")
    if any(n == ATTENTION for _c, _t, n, _x in resultats):
        return ATTENTION, _("KemmOS fonctionne sur cet ordinateur, avec quelques points à connaître.")
    return OK, _("Tout est compatible : KemmOS fonctionne sur cet ordinateur.")


def rapport(resultats, essais=None):
    lignes = [_("Tester mon ordinateur — KemmOS"), bilan(resultats)[1], ""]
    if essais:
        lignes.append(_("Essais faits par l'utilisateur"))
        lignes += [f"  {SYMBOLES[n]} {t} : {x}" for t, (n, x) in essais.items()]
        lignes.append("")
    for cle, titre, _icone in CATEGORIES:
        r = [x for x in resultats if x[0] == cle]
        if r:
            lignes.append(titre)
            lignes += [f"  {SYMBOLES[n]} {t} : {x}" for _c, t, n, x in r]
            lignes.append("")
    return "\n".join(lignes).rstrip() + "\n"


# ---------- fenêtre ----------

def fenetre():
    import gi
    gi.require_version("Gtk", "4.0")
    gi.require_version("Adw", "1")
    from gi.repository import Adw, Gdk, GLib, Gtk
    import threading
    try:
        gi.require_version("Gst", "1.0")
        from gi.repository import Gst
        Gst.init(None)
    except (ValueError, ImportError):
        Gst = None

    def element(nom):
        return Gst is not None and Gst.ElementFactory.find(nom) is not None

    # clavier : touches dessinées (codes evdev, rangées d'un clavier PC 105 touches) ; libellé = disposition en service
    RANGEES = [[1, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 87, 88],
               [41, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
               [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28],
               [58, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 43],
               [42, 86, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54],
               [29, 125, 56, 57, 100, 127, 97, 105, 103, 108, 106]]
    NOMS = {1: "Échap", 14: "⌫", 15: "⇥", 28: "⏎", 58: "⇪", 42: "⇧", 54: "⇧", 29: "Ctrl", 97: "Ctrl",
            125: "❖", 56: "Alt", 100: "AltGr", 57: _("Espace"), 127: "☰", 105: "←", 103: "↑", 108: "↓", 106: "→"}
    LARGES = {14: 2, 15: 2, 28: 2, 58: 2, 42: 2, 54: 3, 57: 7}

    class Essai(Adw.Dialog):
        """Fenêtre d'un essai : contenu, puis question « Ça marche ? » (Oui / Non) → rappel(ok)."""

        def __init__(self, titre, question, rappel, largeur=520):
            super().__init__(title=titre, content_width=largeur)
            self.rappel = rappel
            self.repondu = False
            vue = Adw.ToolbarView()
            vue.add_top_bar(Adw.HeaderBar())
            self.boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18, margin_top=12,
                                 margin_bottom=18, margin_start=18, margin_end=18)
            vue.set_content(self.boite)
            self.set_child(vue)
            self.question = Gtk.Label(label=question, wrap=True, justify=Gtk.Justification.CENTER)
            self.question.add_css_class("title-4")
            boutons = Gtk.Box(spacing=12, halign=Gtk.Align.CENTER)
            non = Gtk.Button(label=_("Non"))
            non.add_css_class("pill")
            non.connect("clicked", lambda _b: self.repondre(False))
            oui = Gtk.Button(label=_("Oui"))
            oui.add_css_class("pill")
            oui.add_css_class("suggested-action")
            oui.connect("clicked", lambda _b: self.repondre(True))
            boutons.append(non)
            boutons.append(oui)
            self.reponses = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
            self.reponses.append(self.question)
            self.reponses.append(boutons)
            self.connect("closed", lambda _d: self.arreter())

        def finir_contenu(self):
            self.boite.append(self.reponses)

        def repondre(self, ok):
            self.repondu = True
            self.arreter()
            self.rappel(ok)
            self.close()

        def arreter(self):
            pass

    class EssaiSon(Essai):
        def __init__(self, rappel):
            super().__init__(_("Son"), _("Avez-vous entendu le son à gauche, puis à droite ?"), rappel)
            self.etat = Gtk.Label(label="", wrap=True)
            self.etat.add_css_class("title-2")
            self.boite.append(self.etat)
            note = Gtk.Label(label=_("Montez le volume si besoin. Casque : la note aiguë doit venir de l'oreille "
                                     "gauche, puis de la droite."), wrap=True, justify=Gtk.Justification.CENTER)
            note.add_css_class("dim-label")
            self.boite.append(note)
            rejouer = Gtk.Button(label=_("Rejouer"), halign=Gtk.Align.CENTER)
            rejouer.connect("clicked", lambda _b: self.jouer())
            self.boite.append(rejouer)
            self.finir_contenu()
            self.tuyau = None
            self.minuteries = []
            self.jouer()

        def jouer(self):
            self.arreter()
            if Gst is None:
                self.etat.set_label(_("Lecture impossible (GStreamer absent)"))
                return
            self.tuyau = Gst.parse_launch("audiotestsrc name=src wave=sine freq=880 volume=0.4 ! audioconvert ! "
                                          "audiopanorama name=pan method=simple panorama=-1 ! audioconvert ! "
                                          "autoaudiosink")
            pan = self.tuyau.get_by_name("pan")
            self.etat.set_label("◀ " + _("Gauche"))
            self.tuyau.set_state(Gst.State.PLAYING)

            def droite():
                pan.set_property("panorama", 1.0)
                self.etat.set_label(_("Droite") + " ▶")
                return False

            def fin():
                self.arreter()
                self.etat.set_label("♪")
                return False
            self.minuteries = [GLib.timeout_add(1500, droite), GLib.timeout_add(3000, fin)]

        def arreter(self):
            for m in self.minuteries:
                GLib.source_remove(m)
            self.minuteries = []
            if self.tuyau is not None:
                self.tuyau.set_state(Gst.State.NULL)
                self.tuyau = None

    class EssaiCamera(Essai):
        def __init__(self, rappel):
            super().__init__(_("Caméra"), _("Voyez-vous l'image de la caméra ?"), rappel, 640)
            self.tuyau = None
            cameras = [c for c in lister("/sys/class/video4linux")
                       if lire(f"/sys/class/video4linux/{c}/index", "0") == "0"]
            if not cameras:
                l = Gtk.Label(label=_("Aucune caméra détectée. Si elle a été coupée dans le Centre KemmOS "
                                      "(onglet Sécurité), rallumez-la d'abord."), wrap=True)
                self.boite.append(l)
                # rien à regarder : pas de question, juste Fermer (le rapport garde « Webcam » de la vérification)
                self.question.set_visible(False)
                self.reponses.get_last_child().set_visible(False)
                fermer = Gtk.Button(label=_("Fermer"), halign=Gtk.Align.CENTER)
                fermer.add_css_class("pill")
                fermer.connect("clicked", lambda _b: self.close())
                self.reponses.append(fermer)
            elif element("gtk4paintablesink") and element("v4l2src"):
                self.image = Gtk.Picture(content_fit=Gtk.ContentFit.CONTAIN, height_request=360)
                self.boite.append(self.image)
                self.tuyau = Gst.parse_launch(f"v4l2src device=/dev/{cameras[0]} ! videoconvert ! "
                                              "gtk4paintablesink name=sortie")
                self.image.set_paintable(self.tuyau.get_by_name("sortie").get_property("paintable"))
                self.tuyau.set_state(Gst.State.PLAYING)
            else:
                b = Gtk.Button(label=_("Ouvrir l'application Caméra"), halign=Gtk.Align.CENTER)
                b.connect("clicked", lambda _b: subprocess.Popen(["snapshot"], start_new_session=True))
                self.boite.append(b)
            self.finir_contenu()

        def arreter(self):
            if self.tuyau is not None:
                self.tuyau.set_state(Gst.State.NULL)
                self.tuyau = None

    class EssaiMicro(Essai):
        def __init__(self, rappel):
            super().__init__(_("Micro"), _("La barre bouge-t-elle quand vous parlez ?"), rappel)
            l = Gtk.Label(label=_("Parlez ou tapez des mains près de l'ordinateur."), wrap=True)
            self.boite.append(l)
            self.barre = Gtk.LevelBar(min_value=0, max_value=1, height_request=24)
            self.barre.add_offset_value("low", 0.5)
            self.barre.add_offset_value("high", 0.8)
            self.boite.append(self.barre)
            self.tuyau = None
            if Gst is None or not element("level"):
                l.set_label(_("Mesure impossible (GStreamer absent)"))
            else:
                self.tuyau = Gst.parse_launch("autoaudiosrc ! audioconvert ! "
                                              "level interval=50000000 post-messages=true ! fakesink sync=false")
                bus = self.tuyau.get_bus()
                bus.add_signal_watch()
                bus.connect("message::element", self.niveau)
                self.tuyau.set_state(Gst.State.PLAYING)
            self.finir_contenu()

        def niveau(self, _bus, message):
            st = message.get_structure()
            if st is None or st.get_name() != "level":
                return
            try:
                db = max(st.get_value("peak"))
            except (TypeError, ValueError):
                return
            self.barre.set_value(min(1.0, max(0.0, (db + 60) / 60)))

        def arreter(self):
            if self.tuyau is not None:
                self.tuyau.get_bus().remove_signal_watch()
                self.tuyau.set_state(Gst.State.NULL)
                self.tuyau = None

    class EssaiClavier(Essai):
        def __init__(self, rappel):
            super().__init__(_("Clavier"), _("Chaque touche appuyée s'allume-t-elle ?"), rappel, 820)
            l = Gtk.Label(label=_("Appuyez sur les touches une à une : elles passent en vert."), wrap=True)
            self.boite.append(l)
            self.touches = {}
            grille = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4, halign=Gtk.Align.CENTER)
            affichage = Gdk.Display.get_default()
            # touche appuyée : fond vert (la classe « success » seule ne colore que le texte, peu visible sur « card »)
            css = Gtk.CssProvider()
            css.load_from_string(".touche-ok { background-color: var(--success-bg-color); "
                                 "color: var(--success-fg-color); }")
            Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), css,
                                                      Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
            for rangee in RANGEES:
                ligne = Gtk.Box(spacing=4)
                for code in rangee:
                    etiquette = NOMS.get(code)
                    if etiquette is None:
                        ok, _cles, valeurs = affichage.map_keycode(code + 8)
                        u = Gdk.keyval_to_unicode(valeurs[0]) if ok and valeurs else 0
                        etiquette = chr(u).upper() if u > 32 else (Gdk.keyval_name(valeurs[0]) if ok and valeurs
                                                                   else "?")
                    t = Gtk.Label(label=etiquette)
                    t.add_css_class("card")
                    t.set_size_request(38 * LARGES.get(code, 1), 34)
                    ligne.append(t)
                    self.touches[code + 8] = t
                grille.append(ligne)
            self.boite.append(grille)
            self.derniere = Gtk.Label(label=" ")
            self.derniere.add_css_class("dim-label")
            self.boite.append(self.derniere)
            touches = Gtk.EventControllerKey()
            touches.set_propagation_phase(Gtk.PropagationPhase.CAPTURE)
            touches.connect("key-pressed", self.appui)
            self.add_controller(touches)
            self.finir_contenu()
            self.question.set_label(_("Chaque touche appuyée s'allume-t-elle ?") + "\n" +
                                    _("(Échap ferme cette fenêtre : cliquez sur Oui ou Non)"))

        def appui(self, _ctrl, keyval, keycode, _etat):
            t = self.touches.get(keycode)
            if t is not None:
                t.add_css_class("touche-ok")
                t.add_css_class("heading")
            self.derniere.set_label(_("Dernière touche : {nom}").format(nom=Gdk.keyval_name(keyval) or keycode))
            return keyval != Gdk.KEY_Escape   # tout est intercepté (Tab, Entrée…), sauf Échap

    class Fenetre(Adw.ApplicationWindow):
        def __init__(self, app):
            super().__init__(application=app, title=_("Tester mon ordinateur"), default_width=760, default_height=720)
            self.toasts = Adw.ToastOverlay()
            vue = Adw.ToolbarView()
            entete = Adw.HeaderBar()
            self.copier = Gtk.Button(label=_("Copier le rapport"), sensitive=False,
                                     tooltip_text=_("Pour une demande d'aide (forum, e-mail)"))
            self.copier.connect("clicked", lambda _b: self.copier_rapport())
            entete.pack_end(self.copier)
            vue.add_top_bar(entete)
            self.page = Adw.PreferencesPage()
            attente = Adw.StatusPage(title=_("Vérification du matériel…"), icon_name="system-search-symbolic")
            attente.set_child(Adw.Spinner() if hasattr(Adw, "Spinner") else Gtk.Spinner(spinning=True))
            vue.set_content(attente)
            self.vue = vue
            self.toasts.set_child(vue)
            self.set_content(self.toasts)
            self.resultats = []
            self.essais = {}
            threading.Thread(target=lambda: GLib.idle_add(self.afficher, tout_verifier()), daemon=True).start()

        def afficher(self, resultats):
            self.resultats = resultats
            niveau, texte = bilan(resultats)
            # en-tête : grand symbole coloré et verdict (pas d'icône emblem-ok : absente du thème Newaita)
            tete = Adw.PreferencesGroup()
            boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6, margin_top=6, margin_bottom=6)
            symbole = Gtk.Label(label=SYMBOLES[niveau])
            symbole.add_css_class("title-1")
            symbole.add_css_class({OK: "success", ATTENTION: "warning", PROBLEME: "error"}[niveau])
            boite.append(symbole)
            verdict = Gtk.Label(label=texte, wrap=True, justify=Gtk.Justification.CENTER)
            verdict.add_css_class("title-3")
            boite.append(verdict)
            note = Gtk.Label(label=_("Rien n'est envoyé sur Internet."))
            note.add_css_class("dim-label")
            boite.append(note)
            tete.add(boite)
            self.page.add(tete)
            # essais à faire soi-même (1.16.0)
            g = Adw.PreferencesGroup(title=_("À essayer vous-même"),
                                     description=_("Ce que l'ordinateur ne peut pas vérifier seul : vos oreilles et "
                                                   "vos yeux sont juges."))
            for cle, titre, sous_titre, icone, classe in (
                    ("son", _("Son"), _("Une note à gauche, puis à droite"), "audio-speakers-symbolic", EssaiSon),
                    ("camera", _("Caméra"), _("Aperçu de l'image"), "camera-web-symbolic", EssaiCamera),
                    ("micro", _("Micro"), _("Niveau du son capté"), "audio-input-microphone-symbolic", EssaiMicro),
                    ("clavier", _("Clavier"), _("Toutes les touches répondent"), "input-keyboard-symbolic",
                     EssaiClavier)):
                ligne = Adw.ActionRow(title=titre, subtitle=sous_titre)
                ligne.add_prefix(Gtk.Image(icon_name=icone))
                resultat = Gtk.Label()
                resultat.add_css_class("title-4")
                ligne.add_suffix(resultat)
                b = Gtk.Button(label=_("Essayer"), valign=Gtk.Align.CENTER)
                b.connect("clicked", lambda _b, t=titre, c=classe, r=resultat:
                          c(lambda ok: self.essai_fait(t, ok, r)).present(self))
                ligne.add_suffix(b)
                g.add(ligne)
            self.page.add(g)
            for cle, titre, icone in CATEGORIES:
                r = [x for x in resultats if x[0] == cle]
                if not r:
                    continue
                g = Adw.PreferencesGroup(title=titre)
                for _c, t, n, x in r:
                    ligne = Adw.ActionRow(title=GLib.markup_escape_text(t), subtitle=GLib.markup_escape_text(x))
                    ligne.set_subtitle_selectable(True)
                    ligne.add_prefix(Gtk.Image(icon_name=icone))
                    p = Gtk.Label(label=SYMBOLES[n])
                    p.add_css_class("title-4")
                    p.add_css_class({OK: "success", ATTENTION: "warning", PROBLEME: "error", INFO: "dim-label"}[n])
                    ligne.add_suffix(p)
                    g.add(ligne)
                self.page.add(g)
            self.vue.set_content(self.page)
            self.copier.set_sensitive(True)
            return False

        def essai_fait(self, titre, ok, resultat):
            self.essais[titre] = (OK, _("fonctionne")) if ok else (PROBLEME, _("ne fonctionne pas"))
            resultat.set_label(SYMBOLES[OK if ok else PROBLEME])
            for c in ("success", "error"):
                resultat.remove_css_class(c)
            resultat.add_css_class("success" if ok else "error")

        def copier_rapport(self):
            Gdk.Display.get_default().get_clipboard().set(rapport(self.resultats, self.essais))
            self.toasts.add_toast(Adw.Toast(title=_("Rapport copié : collez-le dans votre message"), timeout=4))

    class Appli(Adw.Application):
        def __init__(self):
            super().__init__(application_id=APP_ID)

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

    return Appli().run([sys.argv[0]])


if __name__ == "__main__":
    if "--texte" in sys.argv[1:]:
        print(rapport(tout_verifier()), end="")
        sys.exit(0)
    sys.exit(fenetre())
