#!/usr/bin/python3
# Préparer une clé USB KemmOS (Centre KemmOS 1.16.0) : télécharge la dernière ISO de KemmOS (archive.org), vérifie
# sa somme SHA-256 et sa signature GPG (clé KemmOS livrée avec le Centre), puis l'écrit sur une clé USB et relit la
# clé pour s'assurer qu'elle est juste. Usages : installer KemmOS sur un autre ordinateur, réinstaller celui-ci
# (« Tout effacer » avant de le donner ou de le vendre), dépanner.
# L'ISO reste dans le dossier Téléchargements (reprise du téléchargement s'il est interrompu) ; l'écriture passe
# par pkexec (/usr/libexec/kemmos-centre/ecrire-cle, action polkit org.kemmos.centre.cle-usb).
import gettext
import hashlib
import json
import os
import re
import subprocess
import sys
import threading
import time
import urllib.request

import gi

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


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

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


def _traduction(domaine):
    """Langue de l'interface : français (textes d'origine), breton (repli sur le français pour ce qui n'est
    pas encore traduit), anglais pour toutes les autres langues. Renvoie (traduction, code de langue)."""
    code = "fr"
    for var in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
        v = os.environ.get(var, "")
        if v:
            code = v.split(":")[0].split(".")[0].split("@")[0].split("_")[0] or "fr"
            break
    if code in ("C", "POSIX"):
        code = "fr"
    if code == "fr":
        return _Francais(), code
    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.CleUSB"
RECHERCHE = ("https://archive.org/advancedsearch.php?q=identifier%3Akemmos-*&fl%5B%5D=identifier"
             "&rows=100&output=json")
METADONNEES = "https://archive.org/metadata/{id}/files"
TELECHARGER = "https://archive.org/download/{id}/{fichier}"
CLE_GPG = "/usr/share/kemmos/kemmos-iso.gpg"   # clé publique KemmOS (signature des ISO)
AIDE_ECRIRE = "/usr/libexec/kemmos-centre/ecrire-cle"
BLOC = 1024 * 1024
GO = 1024 ** 3
AGENT = "KemmOS-Centre (cle-usb)"


def taille(n):
    if n >= GO:
        t = f"{n / GO:.1f}"
        return t.replace(".", ",") + " Go" if LANGUE in ("fr", "br") else t + " GB"
    t = f"{n / 1024 ** 2:.0f}"
    return t + " Mo" if LANGUE in ("fr", "br") else t + " MB"


def lire_url(url, timeout=30):
    req = urllib.request.Request(url, headers={"User-Agent": AGENT})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        return r.read()


def derniere_version():
    """(identifiant archive.org, version, taille de l'ISO) de la version de KemmOS la plus récente."""
    docs = json.loads(lire_url(RECHERCHE))["response"]["docs"]
    versions = []
    for d in docs:
        m = re.fullmatch(r"kemmos-(\d+(?:\.\d+)*)", d.get("identifier", ""))
        if m:
            versions.append((tuple(int(x) for x in m.group(1).split(".")), d["identifier"], m.group(1)))
    if not versions:
        raise OSError(_("aucune version de KemmOS trouvée sur archive.org"))
    _cle, ident, version = max(versions)
    fichiers = json.loads(lire_url(METADONNEES.format(id=ident))).get("result", [])
    iso = f"KemmOS-{version}.iso"
    tailles = {f["name"]: int(f.get("size") or 0) for f in fichiers}
    if iso not in tailles or f"{iso}.sha256" not in tailles or f"{iso}.sig" not in tailles:
        raise OSError(_("version {v} incomplète sur archive.org").format(v=version))
    return ident, version, tailles[iso]


def cles_usb():
    """Clés USB branchées : disques entiers, en USB, amovibles. [(chemin, nom, taille, a_des_partitions)]"""
    try:
        r = subprocess.run(["lsblk", "-J", "-b", "-d", "-o", "PATH,TYPE,TRAN,RM,HOTPLUG,SIZE,VENDOR,MODEL"],
                           capture_output=True, text=True, timeout=10)
        disques = json.loads(r.stdout)["blockdevices"]
    except (OSError, ValueError, KeyError, subprocess.SubprocessError):
        return []
    res = []
    for d in disques:
        if d.get("type") != "disk" or d.get("tran") != "usb" or not (d.get("rm") or d.get("hotplug")):
            continue
        if not int(d.get("size") or 0):
            continue   # lecteur de cartes vide
        nom = " ".join(x.strip() for x in (d.get("vendor"), d.get("model")) if x and x.strip()) or d["path"]
        parts = subprocess.run(["lsblk", "-n", "-o", "NAME", d["path"]], capture_output=True, text=True).stdout
        res.append((d["path"], nom, int(d["size"]), len(parts.split()) > 1))
    return res


def dossier_telechargements():
    d = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_DOWNLOAD) or os.path.expanduser("~")
    os.makedirs(d, exist_ok=True)
    return d


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, app):
        super().__init__(application=app, title=_("Préparer une clé USB KemmOS"), default_width=620,
                         default_height=720)
        self.version = None          # (identifiant, version, taille)
        self.cles = []
        self.choix = None            # chemin de la clé choisie
        self.travail = False
        self.annuler = threading.Event()
        self.pulsation = False       # étape sans mesure : barre animée

        self.toasts = Adw.ToastOverlay()
        vue = Adw.ToolbarView()
        vue.add_top_bar(Adw.HeaderBar())
        self.page = Adw.PreferencesPage()
        vue.set_content(self.page)
        self.toasts.set_child(vue)
        self.set_content(self.toasts)

        intro = Adw.PreferencesGroup(
            description=_("Une clé USB KemmOS sert à installer KemmOS sur un autre ordinateur, à réinstaller "
                          "celui-ci (par exemple pour tout effacer avant de le donner ou de le vendre), ou à "
                          "dépanner un ordinateur qui ne démarre plus. KemmOS est téléchargé, sa signature est "
                          "vérifiée, puis il est écrit sur la clé, qui est relue pour s'assurer que tout est "
                          "juste."))
        self.page.add(intro)

        self.g_version = Adw.PreferencesGroup(title=_("KemmOS à télécharger"))
        self.l_version = Adw.ActionRow(title=_("Recherche de la dernière version…"))
        self.l_version.add_prefix(Gtk.Image(icon_name="folder-download-symbolic"))
        self.g_version.add(self.l_version)
        self.page.add(self.g_version)

        self.g_cles = Adw.PreferencesGroup(title=_("Clé USB"),
                                           description=_("Tout ce qui se trouve sur la clé choisie sera effacé."))
        self.page.add(self.g_cles)
        self.lignes_cles = []

        self.g_action = Adw.PreferencesGroup()
        boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12)
        self.etape = Gtk.Label(xalign=0, wrap=True)
        self.etape.add_css_class("heading")
        self.barre = Gtk.ProgressBar(show_text=True, visible=False)
        self.detail = Gtk.Label(xalign=0, wrap=True)
        self.detail.add_css_class("dim-label")
        boutons = Gtk.Box(spacing=12, halign=Gtk.Align.CENTER)
        self.b_annuler = Gtk.Button(label=_("Annuler"), visible=False)
        self.b_annuler.connect("clicked", lambda _b: self.annuler.set())
        self.b_go = Gtk.Button(label=_("Préparer la clé"), sensitive=False)
        self.b_go.add_css_class("suggested-action")
        self.b_go.add_css_class("pill")
        self.b_go.connect("clicked", lambda _b: self.confirmer())
        boutons.append(self.b_annuler)
        boutons.append(self.b_go)
        for w in (self.etape, self.barre, self.detail, boutons):
            boite.append(w)
        self.g_action.add(boite)
        self.page.add(self.g_action)

        threading.Thread(target=self.chercher_version, daemon=True).start()
        self.rafraichir_cles()
        GLib.timeout_add_seconds(2, self.rafraichir_cles)
        GLib.timeout_add(150, lambda: (self.pulsation and self.barre.pulse(), True)[1])

    # ----- version -----

    def chercher_version(self):
        try:
            v = derniere_version()
            GLib.idle_add(self.version_trouvee, v, None)
        except (OSError, ValueError, KeyError) as e:
            GLib.idle_add(self.version_trouvee, None, str(getattr(e, "reason", e)))

    def version_trouvee(self, v, erreur):
        if v is None:
            self.l_version.set_title(_("Impossible de joindre archive.org"))
            self.l_version.set_subtitle(_("Vérifiez la connexion à Internet.") + (f" ({erreur})" if erreur else ""))
            b = Gtk.Button(label=_("Réessayer"), valign=Gtk.Align.CENTER)
            b.connect("clicked", lambda b: (self.l_version.remove(b), self.l_version.set_title(
                _("Recherche de la dernière version…")), self.l_version.set_subtitle(""),
                threading.Thread(target=self.chercher_version, daemon=True).start()))
            self.l_version.add_suffix(b)
            return False
        self.version = v
        _ident, version, octets = v
        iso = os.path.join(dossier_telechargements(), f"KemmOS-{version}.iso")
        deja = os.path.exists(iso) and os.path.getsize(iso) == octets
        self.l_version.set_title(_("KemmOS {v}").format(v=version))
        self.l_version.set_subtitle(_("{taille} · déjà téléchargé dans Téléchargements").format(taille=taille(octets))
                                    if deja else _("{taille} à télécharger depuis archive.org").format(
                                        taille=taille(octets)))
        self.mettre_a_jour_bouton()
        return False

    # ----- clés USB -----

    def rafraichir_cles(self):
        if self.travail:
            return True
        cles = cles_usb()
        if cles == self.cles and self.lignes_cles:
            return True
        self.cles = cles
        for r in self.lignes_cles:
            self.g_cles.remove(r)
        self.lignes_cles = []
        if self.choix not in [c[0] for c in cles]:
            self.choix = None
        if not cles:
            r = Adw.ActionRow(title=_("Branchez une clé USB"),
                              subtitle=_("8 Go au moins. Elle apparaîtra ici toute seule."))
            r.add_prefix(Gtk.Image(icon_name="drive-removable-media-symbolic"))
            self.g_cles.add(r)
            self.lignes_cles.append(r)
        premier = None
        mini = self.version[2] if self.version else 0
        for chemin, nom, octets, partitions in cles:
            assez = octets >= mini
            sous_titre = taille(octets)
            if not assez:
                sous_titre += " · " + _("trop petite")
            elif partitions:
                sous_titre += " · " + _("contient des fichiers, qui seront effacés")
            r = Adw.ActionRow(title=nom, subtitle=sous_titre, sensitive=assez)
            r.add_prefix(Gtk.Image(icon_name="drive-removable-media-symbolic"))
            c = Gtk.CheckButton(valign=Gtk.Align.CENTER, active=chemin == self.choix)
            if premier:
                c.set_group(premier)
            premier = premier or c
            c.connect("toggled", lambda b, ch=chemin: b.get_active() and self.choisir(ch))
            r.add_suffix(c)
            r.set_activatable_widget(c)
            self.g_cles.add(r)
            self.lignes_cles.append(r)
            if len([k for k in cles if k[2] >= mini]) == 1 and assez and self.choix is None:
                c.set_active(True)
        self.mettre_a_jour_bouton()
        return True

    def choisir(self, chemin):
        self.choix = chemin
        self.mettre_a_jour_bouton()

    def mettre_a_jour_bouton(self):
        self.b_go.set_sensitive(bool(self.version and self.choix and not self.travail))

    # ----- préparation -----

    def confirmer(self):
        nom = next((c[1] for c in self.cles if c[0] == self.choix), self.choix)
        d = Adw.AlertDialog(heading=_("Effacer la clé « {nom} » ?").format(nom=nom),
                            body=_("Tout ce qui se trouve sur cette clé sera effacé et remplacé par KemmOS {v}. "
                                   "Le mot de passe administrateur sera demandé avant l'écriture.").format(
                                       v=self.version[1]))
        d.add_response("annuler", _("Annuler"))
        d.add_response("ok", _("Effacer et préparer"))
        d.set_response_appearance("ok", Adw.ResponseAppearance.DESTRUCTIVE)
        d.set_default_response("annuler")
        d.connect("response", lambda _d, r: r == "ok" and self.demarrer())
        d.present(self)

    def demarrer(self):
        self.travail = True
        self.annuler.clear()
        self.mettre_a_jour_bouton()
        self.g_cles.set_sensitive(False)
        self.b_annuler.set_visible(True)
        self.barre.set_visible(True)
        threading.Thread(target=self.preparer, args=(self.version, self.choix), daemon=True).start()

    def montrer(self, etape, fraction=None, detail=""):
        def f():
            self.etape.set_label(etape)
            self.pulsation = fraction is None
            if fraction is None:
                self.barre.set_text("")
            else:
                self.barre.set_fraction(fraction)
                self.barre.set_text(f"{fraction * 100:.0f} %")
            self.detail.set_label(detail)
            return False
        GLib.idle_add(f)

    def preparer(self, version, cle):
        ident, v, octets = version
        dossier = dossier_telechargements()
        iso = os.path.join(dossier, f"KemmOS-{v}.iso")
        try:
            somme = self.telecharger_texte(ident, f"KemmOS-{v}.iso.sha256").split()[0].lower()
            sig = os.path.join(dossier, f"KemmOS-{v}.iso.sig")
            with open(sig, "wb") as f:
                f.write(lire_url(TELECHARGER.format(id=ident, fichier=f"KemmOS-{v}.iso.sig")))
            if not (os.path.exists(iso) and os.path.getsize(iso) == octets):
                self.telecharger(TELECHARGER.format(id=ident, fichier=f"KemmOS-{v}.iso"), iso, octets)
            self.montrer(_("Vérification du fichier téléchargé…"), 0)
            h = hashlib.sha256()
            fait = 0
            with open(iso, "rb") as f:
                while b := f.read(BLOC * 4):
                    if self.annuler.is_set():
                        raise InterruptedError
                    h.update(b)
                    fait += len(b)
                    if fait % (BLOC * 256) < BLOC * 4:
                        self.montrer(_("Vérification du fichier téléchargé…"), fait / octets)
            if h.hexdigest() != somme:
                os.remove(iso)   # fichier abîmé : retéléchargé la prochaine fois
                raise OSError(_("le fichier téléchargé est abîmé (somme SHA-256 différente) : il a été supprimé, "
                                "recommencez"))
            self.montrer(_("Vérification de la signature de KemmOS…"))
            r = subprocess.run(["gpgv", "--keyring", CLE_GPG, sig, iso], capture_output=True, text=True)
            if r.returncode != 0:
                raise OSError(_("la signature ne correspond pas à la clé KemmOS : ce fichier ne vient pas de "
                                "KemmOS, il n'a pas été écrit"))
            GLib.idle_add(lambda: self.b_annuler.set_visible(False))
            self.montrer(_("Écriture sur la clé… (mot de passe administrateur)"))
            GLib.idle_add(self.ecrire, iso, somme, cle)
        except InterruptedError:
            GLib.idle_add(self.fin, None, _("Préparation annulée. Le téléchargement reprendra où il s'est arrêté."))
        except (OSError, ValueError, IndexError) as e:
            GLib.idle_add(self.fin, False, str(getattr(e, "reason", e)))

    def telecharger_texte(self, ident, fichier):
        return lire_url(TELECHARGER.format(id=ident, fichier=fichier)).decode()

    def telecharger(self, url, iso, octets):
        """Téléchargement avec reprise (.part) ; avancement, vitesse et temps restant."""
        part = iso + ".part"
        deja = os.path.getsize(part) if os.path.exists(part) else 0
        if deja > octets:
            os.remove(part)
            deja = 0
        libre = os.statvfs(os.path.dirname(iso))
        if libre.f_bavail * libre.f_frsize < octets - deja + 200 * 1024 ** 2:
            raise OSError(_("pas assez de place dans Téléchargements ({taille} nécessaires)").format(
                taille=taille(octets - deja)))
        req = urllib.request.Request(url, headers={"User-Agent": AGENT, **({"Range": f"bytes={deja}-"} if deja
                                                                            else {})})
        debut, debut_octets = time.monotonic(), deja
        with urllib.request.urlopen(req, timeout=60) as r, open(part, "ab" if deja else "wb") as f:
            if deja and r.status != 206:   # le serveur ne reprend pas : on recommence
                f.truncate(0)
                deja = debut_octets = 0
            dernier = 0
            while b := r.read(BLOC):
                if self.annuler.is_set():
                    raise InterruptedError
                f.write(b)
                deja += len(b)
                maintenant = time.monotonic()
                if maintenant - dernier > 0.5:
                    dernier = maintenant
                    vitesse = (deja - debut_octets) / max(maintenant - debut, 0.1)
                    reste = (octets - deja) / vitesse if vitesse > 0 else 0
                    self.montrer(_("Téléchargement de KemmOS…"), deja / octets,
                                 _("{fait} sur {total} · {vitesse}/s · encore {minutes} min environ").format(
                                     fait=taille(deja), total=taille(octets), vitesse=taille(vitesse),
                                     minutes=max(1, round(reste / 60))))
        if os.path.getsize(part) != octets:
            raise OSError(_("téléchargement incomplet : relancez, il reprendra où il s'est arrêté"))
        os.replace(part, iso)

    def ecrire(self, iso, somme, cle):
        try:
            p = Gio.Subprocess.new(["pkexec", AIDE_ECRIRE, iso, somme, cle],
                                   Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_MERGE)
        except GLib.Error as e:
            self.fin(False, e.message)
            return False
        flux = Gio.DataInputStream.new(p.get_stdout_pipe())
        derniere = [""]

        def ligne(f, res):
            try:
                texte, _n = f.read_line_finish_utf8(res)
            except GLib.Error:
                texte = None
            if texte is None:
                p.wait_async(None, lambda pr, r: (pr.wait_finish(r), self.ecriture_finie(pr.get_exit_status(),
                                                                                            derniere[0])))
                return
            m = re.fullmatch(r"(ECRITURE|VERIFICATION) (\d+) (\d+)", texte.strip())
            if m:
                fraction = int(m.group(2)) / max(int(m.group(3)), 1)
                self.montrer(_("Écriture sur la clé…") if m.group(1) == "ECRITURE"
                             else _("Relecture de la clé pour vérifier…"), fraction)
            elif texte.strip():
                derniere[0] = texte.strip()
            f.read_line_async(GLib.PRIORITY_DEFAULT, None, ligne)
        flux.read_line_async(GLib.PRIORITY_DEFAULT, None, ligne)
        return False

    def ecriture_finie(self, code, derniere):
        if code == 0 and derniere == "TERMINE":
            self.fin(True, None)
        elif code in (126, 127):
            self.fin(None, _("Annulé (mot de passe non fourni). Le fichier téléchargé est gardé."))
        else:
            self.fin(False, derniere or _("erreur inconnue"))

    def fin(self, ok, texte):
        self.travail = False
        self.pulsation = False
        self.b_annuler.set_visible(False)
        self.g_cles.set_sensitive(True)
        self.mettre_a_jour_bouton()
        if ok:
            self.barre.set_fraction(1)
            self.barre.set_text("100 %")
            self.etape.set_label(_("La clé USB KemmOS est prête !"))
            self.detail.set_label(_("Pour démarrer dessus : éteignez l'ordinateur, branchez la clé, puis allumez-le "
                                    "en appuyant plusieurs fois sur la touche du menu de démarrage (souvent F12, "
                                    "F11, F8 ou Échap, selon la marque) et choisissez la clé USB. KemmOS démarre "
                                    "alors sans rien changer à l'ordinateur ; l'installation ne se fait que si vous "
                                    "la lancez. Réinstaller efface tout le disque : sauvegardez d'abord vos "
                                    "fichiers."))
            self.b_go.set_label(_("Préparer une autre clé"))
        elif ok is None:
            self.barre.set_visible(False)
            self.etape.set_label(texte)
            self.detail.set_label("")
        else:
            self.barre.set_visible(False)
            self.etape.set_label(_("La clé n'a pas pu être préparée"))
            self.detail.set_label(texte)
        self.cles = []   # liste reconstruite (la clé a changé de contenu)
        self.rafraichir_cles()
        return False


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()


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