#!/usr/bin/python3
# Assistant « Je viens de Windows » (Centre KemmOS 1.8.0) : récupère les fichiers et les favoris d'un Windows
# installé sur l'ordinateur, puis montre les équivalents des programmes Windows dans KemmOS.
# Windows n'est jamais modifié : la partition est ouverte en lecture seule par l'aide pkexec
# /usr/libexec/kemmos-centre/windows (BitLocker : clé de récupération demandée), refermée par windows-fermer.
# La copie se fait ici, en utilisateur normal, sans rien écraser.
# « kemmos-windows --detecter » : code 0 si une partition Windows est visible (fenêtre de bienvenue).
# « kemmos-windows --equivalents » : ouvre directement la page des équivalents.
# Centre 1.12.0 : traduit en breton et en anglais (domaine kemmos-centre, comme le Centre).
import gettext
import json
import os
import re
import shutil
import sqlite3
import subprocess
import sys
import threading
import time
from html import escape


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

AIDE = "/usr/libexec/kemmos-centre/windows"
AIDE_FERMER = "/usr/libexec/kemmos-centre/windows-fermer"
TAILLE_MIN = 20 * 10**9          # en dessous : partition de récupération, pas Windows
WINRE = "de94bba4-06d1-4d40-a16a-bfd50179d6ac"   # type GPT « Windows Recovery Environment »
MARGE = 2 * 10**9                # place à laisser libre après la copie
COMPTES_SYSTEME = {"all users", "default", "default user", "public", "defaultaccount", "wdagutilityaccount"}
IGNORES = {"desktop.ini", "thumbs.db", "ntuser.dat"}


def partitions_windows():
    try:
        r = subprocess.run(["lsblk", "-J", "-b", "-o", "PATH,TYPE,FSTYPE,SIZE,LABEL,PARTTYPE,MODEL"],
                           capture_output=True, text=True, timeout=10)
        arbre = json.loads(r.stdout)["blockdevices"]
    except (OSError, ValueError, subprocess.SubprocessError):
        return []
    trouvees, pile = [], [(b, None) for b in arbre]
    while pile:
        b, disque = pile.pop(0)
        if b.get("type") == "disk":
            disque = b.get("model") or b["path"]
        if (b.get("fstype") in ("ntfs", "BitLocker") and (b.get("size") or 0) >= TAILLE_MIN
                and (b.get("parttype") or "").lower() != WINRE):
            trouvees.append({"chemin": b["path"], "taille": b["size"], "nom": b.get("label") or "",
                             "bitlocker": b["fstype"] == "BitLocker", "disque": (disque or "").strip()})
        pile += [(e, disque) for e in b.get("children") or []]
    return trouvees


if __name__ == "__main__" and "--detecter" in sys.argv[1:]:
    sys.exit(0 if partitions_windows() else 1)

import gi  # noqa: E402

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
from gi.repository import Adw, Gio, GLib, Gtk  # noqa: E402
try:   # GLib ≥ 2.86 : Gio.DesktopAppInfo déplacé dans GioUnix
    gi.require_version("GioUnix", "2.0")
    from gi.repository.GioUnix import DesktopAppInfo  # noqa: E402
except (ValueError, ImportError):
    DesktopAppInfo = Gio.DesktopAppInfo


def dossier_xdg(genre, defaut):
    d = GLib.get_user_special_dir(genre)
    return d if d and d != os.path.expanduser("~") else os.path.expanduser("~/" + defaut)


# (clé, titre, noms possibles dans C:\Users\<compte> et dans OneDrive, destination, coché par défaut)
DOSSIERS = [
    ("documents", _("Documents"), ["Documents"],
     lambda: dossier_xdg(GLib.UserDirectory.DIRECTORY_DOCUMENTS, "Documents"), True),
    ("images", _("Images"), ["Pictures", "Images"],
     lambda: dossier_xdg(GLib.UserDirectory.DIRECTORY_PICTURES, "Images"), True),
    ("musique", _("Musique"), ["Music", "Musique"],
     lambda: dossier_xdg(GLib.UserDirectory.DIRECTORY_MUSIC, "Musique"), True),
    ("videos", _("Vidéos"), ["Videos", "Vidéos"],
     lambda: dossier_xdg(GLib.UserDirectory.DIRECTORY_VIDEOS, "Vidéos"), True),
    # pas d'icônes sur le bureau de GNOME : le Bureau de Windows va dans un dossier de Documents
    ("bureau", _("Bureau"), ["Desktop", "Bureau"],
     lambda: os.path.join(dossier_xdg(GLib.UserDirectory.DIRECTORY_DOCUMENTS, "Documents"), _("Bureau de Windows")),
     True),
    ("telechargements", _("Téléchargements"), ["Downloads", "Téléchargements"],
     lambda: dossier_xdg(GLib.UserDirectory.DIRECTORY_DOWNLOAD, "Téléchargements"), False),
]

# Programme Windows → équivalent : (titre, sous-titre, identifiants .desktop possibles, identifiant
# AppStream pour « Installer » s'il manque)
EQUIVALENTS = [
    (_("Internet"), [
        (_("Edge, Chrome → Brave"), _("Navigateur rapide, bloque les publicités"),
         ["com.brave.Browser"], "com.brave.Browser"),
        (_("Firefox → LibreWolf"), _("Firefox avec plus de vie privée (menus en anglais)"),
         ["io.gitlab.librewolf-community"], "io.gitlab.librewolf-community"),
        (_("Outlook, Courrier → Evolution"), _("Courriels, agenda et contacts"),
         ["org.gnome.Evolution"], "org.gnome.Evolution"),
        (_("YouTube → FreeTube"), _("Vidéos YouTube sans publicité ni pistage"),
         ["io.freetubeapp.FreeTube"], "io.freetubeapp.FreeTube"),
        (_("Bureau à distance → Connexions"), _("Se connecter à un autre ordinateur"),
         ["org.gnome.Connections"], "org.gnome.Connections"),
    ]),
    (_("Bureautique"), [
        (_("Word → LibreOffice Writer"), _("Ouvre et enregistre les fichiers .docx"),
         ["libreoffice-writer", "writer"], "org.libreoffice.LibreOffice"),
        (_("Excel → LibreOffice Calc"), _("Ouvre et enregistre les fichiers .xlsx"),
         ["libreoffice-calc", "calc"], "org.libreoffice.LibreOffice"),
        (_("PowerPoint → LibreOffice Impress"), _("Ouvre et enregistre les fichiers .pptx"),
         ["libreoffice-impress", "impress"], "org.libreoffice.LibreOffice"),
        (_("Adobe Reader → Papers"), _("Lire les PDF"),
         ["org.gnome.Papers"], "org.gnome.Papers"),
        (_("Bloc-notes → Éditeur de texte"), _("Notes et fichiers texte"),
         ["org.gnome.TextEditor"], "org.gnome.TextEditor"),
        (_("Calculatrice → Calculatrice"), "",
         ["org.gnome.Calculator"], "org.gnome.Calculator"),
        (_("Numériser → Numériseur"), _("Scanner des documents"),
         ["simple-scan", "org.gnome.SimpleScan"], "org.gnome.SimpleScan"),
    ]),
    (_("Images, musique et vidéo"), [
        (_("Paint → Pinta"), _("Dessiner, retoucher, recadrer une image"),
         ["com.github.PintaProject.Pinta"], "com.github.PintaProject.Pinta"),
        (_("Photos → Visionneuse d'images"), _("Regarder ses photos"),
         ["org.gnome.Loupe"], "org.gnome.Loupe"),
        (_("Lecteur multimédia, Films et TV → VLC"), _("Lit toutes les vidéos et la musique"),
         ["org.videolan.VLC"], "org.videolan.VLC"),
        (_("Caméra → Snapshot"), _("Photos et vidéos avec la webcam"),
         ["org.gnome.Snapshot"], "org.gnome.Snapshot"),
        (_("Outil Capture d'écran → touche Impr. écran"), _("Capture intégrée : appuyez sur Impr. écran"), [], None),
    ]),
    (_("Système"), [
        (_("Explorateur de fichiers → Fichiers"), _("Vos dossiers, clés USB et disques"),
         ["org.gnome.Nautilus"], "org.gnome.Nautilus"),
        (_("Paramètres, Panneau de configuration → Paramètres"), _("Écran, son, wifi, imprimantes, comptes"),
         ["org.gnome.Settings"], "org.gnome.Settings"),
        (_("Windows Update → KemmOS-Update"), _("Icône dans la barre du haut"),
         ["kemmos-update-tray"], None),
        (_("Microsoft Store → KemmOS-Apps"), _("Installer d'autres applications (Flathub)"),
         ["org.kemmos.Apps"], None),
        (_("Sécurité Windows → Centre KemmOS"), _("Pare-feu, antivirus, points de restauration"),
         ["org.kemmos.Centre"], None),
        (_("Gestionnaire des tâches → Resources"), _("Processeur, mémoire, programmes en cours"),
         ["net.nokyan.Resources"], "net.nokyan.Resources"),
        (_("Gestion des disques → Disques"), _("Partitions, formatage de clés USB"),
         ["org.gnome.DiskUtility"], "org.gnome.DiskUtility"),
        (_("7-Zip, WinRAR → Gestionnaire d'archives"), _("Ouvre les .zip, .rar, .7z d'un double-clic"),
         ["org.gnome.FileRoller"], "org.gnome.FileRoller"),
        (_("Historique des fichiers → Sauvegardes (Déjà Dup)"), _("Copie de vos fichiers sur un disque externe"),
         ["org.gnome.DejaDup"], "org.gnome.DejaDup"),
        (_("Gestionnaire de mots de passe → KeePassXC"), _("Coffre-fort de mots de passe"),
         ["org.keepassxc.KeePassXC"], "org.keepassxc.KeePassXC"),
        (_("Programmes et jeux Windows → Bottles"), _("Groupe Jeux, onglet Logiciels du Centre KemmOS"),
         ["com.usebottles.bottles"], "com.usebottles.bottles"),
    ]),
]


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


def appli(ids):
    # appli absente : PyGObject lève TypeError (« constructor returned NULL ») au lieu de renvoyer None
    for i in ids:
        try:
            return DesktopAppInfo.new(i + ".desktop")
        except TypeError:
            continue
    return None


def sources(compte, noms):
    # dossiers C:\Users\<compte>\<nom> et C:\Users\<compte>\OneDrive*\<nom> (dossiers déplacés par OneDrive)
    racines = [compte] + sorted(os.path.join(compte, d) for d in lister(compte)
                                if d.lower().startswith("onedrive") and os.path.isdir(os.path.join(compte, d))
                                and not os.path.islink(os.path.join(compte, d)))
    vus, res = set(), []
    for r in racines:
        for n in noms:
            p = os.path.join(r, n)
            if os.path.isdir(p) and not os.path.islink(p) and os.path.realpath(p) not in vus:
                vus.add(os.path.realpath(p))
                res.append(p)
    return res


def lister(d):
    try:
        return os.listdir(d)
    except OSError:
        return []


def fichiers(dossier):
    # (chemin, chemin relatif, taille) ; liens et jonctions (« Ma musique »…) ignorés, comme les fichiers
    # cachés de Windows qui n'ont pas de sens ici
    for racine, dirs, noms in os.walk(dossier, onerror=lambda e: None):
        dirs[:] = [d for d in dirs if not os.path.islink(os.path.join(racine, d))]
        for n in noms:
            if n.lower() in IGNORES or n.startswith("~$") or n.lower().endswith(".lnk"):
                continue
            p = os.path.join(racine, n)
            try:
                if os.path.islink(p) or not os.path.isfile(p):
                    continue
                yield p, os.path.relpath(p, dossier), os.path.getsize(p)
            except OSError:
                continue


def libre(chemin):
    while not os.path.exists(chemin):
        chemin = os.path.dirname(chemin)
    st = os.statvfs(chemin)
    return st.f_bavail * st.f_frsize


def nom_libre(dest):
    base, ext = os.path.splitext(dest)
    n = 2
    while os.path.exists(f"{base} ({n}){ext}"):
        n += 1
    return f"{base} ({n}){ext}"


# ---------- favoris ----------

def favoris_chromium(fichier):
    with open(fichier, encoding="utf-8") as f:
        racines = json.load(f).get("roots", {})

    def noeud(n):
        if n.get("type") == "url":
            return {"titre": n.get("name") or n.get("url"), "url": n.get("url")}
        return {"titre": n.get("name") or "", "enfants": [noeud(e) for e in n.get("children", [])]}

    res = []
    for cle, titre in (("bookmark_bar", _("Barre de favoris")), ("other", _("Autres favoris")),
                       ("synced", _("Favoris sur mobile"))):
        if cle in racines and racines[cle].get("children"):
            d = noeud(racines[cle])
            d["titre"] = titre
            res.append(d)
    return res


def favoris_firefox(fichier):
    # base en lecture seule sur un disque monté en lecture seule : immutable=1
    con = sqlite3.connect(f"file:{fichier}?immutable=1", uri=True)
    try:
        lignes = con.execute("SELECT b.id, b.type, b.parent, b.title, p.url, b.guid FROM moz_bookmarks b "
                             "LEFT JOIN moz_places p ON b.fk = p.id ORDER BY b.parent, b.position").fetchall()
    finally:
        con.close()
    noeuds = {}
    for i, typ, parent, titre, url, guid in lignes:
        if typ == 1 and url and not url.startswith("place:"):
            noeuds[i] = {"titre": titre or url, "url": url, "parent": parent, "guid": guid}
        elif typ == 2:
            noeuds[i] = {"titre": titre or "", "enfants": [], "parent": parent, "guid": guid}
    for i, n in noeuds.items():
        p = noeuds.get(n["parent"])
        if p is not None and "enfants" in p and i != n["parent"]:
            p["enfants"].append(n)
    noms = {"menu________": _("Menu des marque-pages"), "toolbar_____": _("Barre personnelle"),
            "unfiled_____": _("Autres marque-pages"), "mobile______": _("Marque-pages sur mobile")}
    res = []
    for n in noeuds.values():
        if n["guid"] in noms and n.get("enfants"):
            n["titre"] = noms[n["guid"]]
            res.append(n)
    return res


def chercher_favoris(compte):
    # [(nom du navigateur, arbre)] : Edge, Chrome, Brave (tous les profils) et Firefox
    res = []
    local = os.path.join(compte, "AppData", "Local")
    for nom, chemin in (("Edge", "Microsoft/Edge/User Data"), ("Chrome", "Google/Chrome/User Data"),
                        ("Brave", "BraveSoftware/Brave-Browser/User Data")):
        base = os.path.join(local, chemin)
        profils = sorted(p for p in lister(base) if p == "Default" or p.startswith("Profile "))
        for p in profils:
            f = os.path.join(base, p, "Bookmarks")
            if os.path.isfile(f):
                try:
                    arbre = favoris_chromium(f)
                except (OSError, ValueError):
                    continue
                if arbre:
                    res.append((nom if p == "Default" else f"{nom} ({p.replace('Profile', 'profil')})", arbre))
    base = os.path.join(compte, "AppData", "Roaming", "Mozilla", "Firefox", "Profiles")
    for p in sorted(lister(base)):
        f = os.path.join(base, p, "places.sqlite")
        if os.path.isfile(f):
            try:
                arbre = favoris_firefox(f)
            except sqlite3.Error:
                continue
            if arbre:
                res.append(("Firefox" if len(res) == 0 or not any(r[0].startswith("Firefox") for r in res)
                            else _("Firefox ({profil})").format(profil=p.split(".", 1)[-1]), arbre))
    return res


def compter(arbre):
    return sum(compter(n["enfants"]) if "enfants" in n else 1 for n in arbre)


def favoris_html(navigateurs):
    # format « Netscape Bookmark File », importé par Brave, LibreWolf, Firefox, Chrome…
    l = ["<!DOCTYPE NETSCAPE-Bookmark-file-1>",
         '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">',
         "<TITLE>Favoris de Windows</TITLE>", "<H1>Favoris de Windows</H1>", "<DL><p>"]

    def dossier(titre, enfants, ind):
        l.append(f"{ind}<DT><H3>{escape(titre)}</H3>")
        l.append(f"{ind}<DL><p>")
        for n in enfants:
            if "enfants" in n:
                dossier(n["titre"], n["enfants"], ind + "    ")
            else:
                l.append(f'{ind}    <DT><A HREF="{escape(n["url"])}">{escape(n["titre"])}</A>')
        l.append(f"{ind}</DL><p>")

    for nom, arbre in navigateurs:
        dossier(nom, arbre, "    ")
    l.append("</DL><p>")
    return "\n".join(l) + "\n"


def ecrire_favoris(navigateurs, fichier):
    # renvoie le fichier écrit ; assistant relancé avec les mêmes favoris : le fichier existant est gardé
    texte = favoris_html(navigateurs)
    try:
        with open(fichier, encoding="utf-8") as f:
            if f.read() == texte:
                return fichier
        fichier = nom_libre(fichier)
    except FileNotFoundError:
        pass
    os.makedirs(os.path.dirname(fichier), exist_ok=True)
    with open(fichier, "w", encoding="utf-8") as f:
        f.write(texte)
    return fichier


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

class Assistant(Adw.ApplicationWindow):
    def __init__(self, app, equivalents_seuls=False):
        super().__init__(application=app, title=_("Je viens de Windows"), default_width=640, default_height=720)
        self.nav = Adw.NavigationView()
        self.toasts = Adw.ToastOverlay(child=self.nav)
        self.set_content(self.toasts)
        self.point = None          # point de montage de Windows
        self.compte = None
        self.tailles = {}
        self.cases = {}
        self.arreter = False
        self.connect("close-request", self.fermer_windows)
        if equivalents_seuls:
            self.nav.add(self.page_equivalents())
        else:
            self.nav.add(self.page_accueil())

    # pages : Adw.NavigationPage avec barre de titre, contenu défilant
    def page(self, titre, contenu, tag=None, bas=None):
        vue = Adw.ToolbarView()
        vue.add_top_bar(Adw.HeaderBar())
        vue.set_content(contenu)
        if bas:
            barre = Gtk.Box(halign=Gtk.Align.CENTER, spacing=12, margin_top=12, margin_bottom=18)
            for b in bas:
                barre.append(b)
            vue.add_bottom_bar(barre)
        return Adw.NavigationPage(title=titre, child=vue, tag=tag or titre)

    def bouton(self, label, rappel, style="suggested-action"):
        b = Gtk.Button(label=label)
        b.add_css_class("pill")
        if style:
            b.add_css_class(style)
        b.connect("clicked", lambda _b: rappel())
        return b

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

    def page_accueil(self):
        pref = Adw.PreferencesPage()
        g = Adw.PreferencesGroup()
        st = Adw.StatusPage(icon_name="folder-download-symbolic", title=_("Je viens de Windows"),
                            description=_("Récupérez vos documents, photos, musique et favoris depuis Windows, "
                                          "puis découvrez les équivalents de vos programmes.\n\n"
                                          "<b>Windows n'est jamais modifié</b> : il est seulement lu."))
        st.add_css_class("compact")
        g.add(st)
        pref.add(g)
        self.parts = partitions_windows()
        self.choix_part = None
        bas = []
        if self.parts:
            g = Adw.PreferencesGroup(title=_("Windows trouvé") if len(self.parts) == 1 else _("Partitions Windows trouvées"),
                                     description=_("Si vous avez plusieurs partitions, choisissez celle qui "
                                                   "contient Windows (souvent la plus grande, « C: »)."))
            premier = None
            for p in sorted(self.parts, key=lambda p: -p["taille"]):
                radio = Gtk.CheckButton(group=premier)
                premier = premier or radio
                sous = f"{taille(p['taille'])}"
                if p["nom"]:
                    sous += f" · {p['nom']}"
                if p["disque"]:
                    sous += _(" · disque {disque}").format(disque=p["disque"])
                if p["bitlocker"]:
                    sous += _(" · protégé par BitLocker")
                r = Adw.ActionRow(title=p["chemin"], subtitle=sous, activatable_widget=radio)
                r.add_prefix(radio)
                r.add_suffix(Gtk.Image(icon_name="channel-secure-symbolic" if p["bitlocker"]
                                       else "drive-harddisk-symbolic"))
                radio.connect("toggled", lambda b, p=p: b.get_active() and setattr(self, "choix_part", p))
                if radio is premier:
                    radio.set_active(True)
                    self.choix_part = p
                g.add(r)
            pref.add(g)
            self.btn_commencer = self.bouton(_("Récupérer mes fichiers"), self.commencer)
            bas.append(self.btn_commencer)
        else:
            g = Adw.PreferencesGroup()
            g.add(Adw.ActionRow(title=_("Aucun Windows trouvé sur cet ordinateur"),
                                subtitle=_("Vous pouvez quand même découvrir les équivalents de vos programmes. "
                                           "Fichiers sur une clé USB ou un disque externe : ouvrez-les avec "
                                           "Fichiers et copiez-les.")))
            pref.add(g)
        bas.append(self.bouton(_("Équivalents des programmes"),
                               lambda: self.nav.push(self.page_equivalents()), None))
        return self.page(_("Je viens de Windows"), pref, "accueil", bas)

    # ---- ouverture de la partition ----

    def commencer(self):
        p = self.choix_part
        if p["bitlocker"]:
            self.nav.push(self.page_cle())
        else:
            self.ouvrir("")

    def page_cle(self):
        pref = Adw.PreferencesPage()
        g = Adw.PreferencesGroup(
            title=_("Disque protégé par BitLocker"),
            description=_("Windows a chiffré ce disque (c'est automatique sur beaucoup d'ordinateurs avec "
                          "Windows 11). Pour le lire, il faut votre <b>clé de récupération</b> : 48 chiffres, "
                          "en 8 blocs de 6.\n\n"
                          "Où la trouver : sur <b>aka.ms/myrecoverykey</b> (en vous connectant avec votre compte "
                          "Microsoft, depuis un téléphone ou cet ordinateur), ou sur un papier ou une clé USB "
                          "si vous l'aviez enregistrée. La clé n'est pas conservée par KemmOS."))
        lien = Gtk.LinkButton(uri="https://aka.ms/myrecoverykey", label=_("Ouvrir aka.ms/myrecoverykey"),
                              halign=Gtk.Align.START)
        self.entree_cle = Adw.EntryRow(title=_("Clé de récupération (ou mot de passe BitLocker)"))
        self.entree_cle.connect("entry-activated", lambda _e: self.ouvrir(self.entree_cle.get_text()))
        g.add(self.entree_cle)
        pref.add(g)
        g2 = Adw.PreferencesGroup()
        g2.add(lien)
        pref.add(g2)
        self.btn_cle = self.bouton(_("Déverrouiller"), lambda: self.ouvrir(self.entree_cle.get_text()))
        return self.page(_("Clé BitLocker"), pref, "cle", [self.btn_cle])

    def occupe(self, oui):
        for b in (getattr(self, "btn_commencer", None), getattr(self, "btn_cle", None)):
            if b:
                b.set_sensitive(not oui)
                b.set_label(_("Ouverture…") if oui else (_("Déverrouiller") if b is getattr(self, "btn_cle", None)
                                                       else _("Récupérer mes fichiers")))

    def ouvrir(self, cle):
        if self.choix_part["bitlocker"] and not cle.strip():
            self.toast(_("Saisissez la clé de récupération"))
            return
        self.occupe(True)
        try:
            proc = Gio.Subprocess.new(["pkexec", AIDE, "ouvrir", self.choix_part["chemin"]],
                                      Gio.SubprocessFlags.STDIN_PIPE | Gio.SubprocessFlags.STDOUT_PIPE
                                      | Gio.SubprocessFlags.STDERR_PIPE)
        except GLib.Error as e:
            self.occupe(False)
            self.toast(_("Échec : {message}").format(message=e.message))
            return

        def fini(p, res):
            self.occupe(False)
            try:
                _ok, sortie, erreur = p.communicate_utf8_finish(res)
            except GLib.Error as e:
                self.toast(_("Échec : {message}").format(message=e.message))
                return
            code = p.get_exit_status()
            if code == 0 and sortie.strip():
                self.point = sortie.strip().splitlines()[-1]
                self.apres_ouverture()
            elif code == 3:
                self.toast(_("Clé refusée : vérifiez les 48 chiffres"))
            elif code == 126:
                self.toast(_("Mot de passe annulé"))
            elif code == 127:
                self.toast(_("Autorisation refusée (mot de passe incorrect ?)"))
            else:
                d = Adw.AlertDialog(heading=_("Lecture de Windows impossible"),
                                    body=(erreur or sortie or "").strip()[-600:] or _("code {code}").format(code=code))
                d.add_response("ok", _("Fermer"))
                d.present(self)
        proc.communicate_utf8_async(cle.strip() + "\n", None, fini)

    def apres_ouverture(self):
        users = os.path.join(self.point, "Users")
        if not os.path.isdir(users):
            self.nav.push(self.page_message(
                _("Pas de dossiers d'utilisateurs ici"),
                _("Cette partition ne contient pas le dossier « Users » de Windows : c'est sans doute une "
                  "partition de données (D:). Vous pouvez la parcourir avec Fichiers et copier ce que vous "
                  "voulez, ou revenir en arrière et choisir une autre partition."),
                [self.bouton(_("Ouvrir dans Fichiers"), lambda: Gio.AppInfo.launch_default_for_uri(
                    GLib.filename_to_uri(self.point), None), None)]))
            return
        comptes = sorted(d for d in lister(users)
                         if d.lower() not in COMPTES_SYSTEME and os.path.isdir(os.path.join(users, d))
                         and not os.path.islink(os.path.join(users, d)))
        if not comptes:
            self.nav.push(self.page_message(_("Aucun compte trouvé"),
                                            _("Le dossier « Users » de Windows ne contient aucun compte."), []))
        elif len(comptes) == 1:
            self.choisir_compte(os.path.join(users, comptes[0]))
        else:
            pref = Adw.PreferencesPage()
            g = Adw.PreferencesGroup(title=_("Quel compte Windows est le vôtre ?"))
            for c in comptes:
                r = Adw.ActionRow(title=GLib.markup_escape_text(c), activatable=True)
                r.add_prefix(Gtk.Image(icon_name="avatar-default-symbolic"))
                r.add_suffix(Gtk.Image(icon_name="go-next-symbolic"))
                r.connect("activated", lambda _r, c=c: self.choisir_compte(os.path.join(users, c)))
                g.add(r)
            pref.add(g)
            self.nav.push(self.page(_("Compte Windows"), pref, "comptes"))

    def page_message(self, titre, texte, boutons):
        st = Adw.StatusPage(icon_name="dialog-information-symbolic", title=titre, description=texte)
        return self.page(titre, st, None, boutons)

    # ---- choix et copie ----

    def choisir_compte(self, compte):
        self.compte = compte
        self.tailles = {}
        pref = Adw.PreferencesPage()
        g = Adw.PreferencesGroup(title=_("Compte « {compte} » : que voulez-vous récupérer ?").format(
                                     compte=GLib.markup_escape_text(os.path.basename(compte))),
                                 description=_("Copié dans vos dossiers du même nom. Rien n'est écrasé : un "
                                               "fichier qui existe déjà sous un autre contenu est enregistré "
                                               "avec « (2) » dans son nom."))
        self.cases, self.lignes = {}, {}
        for cle, titre, noms, dest, defaut in DOSSIERS:
            src = sources(compte, noms)
            case = Gtk.CheckButton(active=defaut and bool(src), sensitive=bool(src))
            r = Adw.ActionRow(title=titre, activatable_widget=case,
                              subtitle=_("calcul de la taille…") if src else _("dossier vide ou absent"))
            r.add_prefix(case)
            case.connect("toggled", lambda _c: self.maj_total())
            g.add(r)
            self.cases[cle], self.lignes[cle] = case, r
            self.tailles[cle] = None if src else (0, 0)
        self.navigateurs = chercher_favoris(compte)
        n = sum(compter(a) for _nom, a in self.navigateurs)
        self.case_fav = Gtk.CheckButton(active=n > 0, sensitive=n > 0)
        noms = ", ".join(sorted({nom.split(" (")[0] for nom, _a in self.navigateurs}))
        r = Adw.ActionRow(title=_("Favoris des navigateurs"), activatable_widget=self.case_fav,
                          subtitle=ngettext("{n} favori ({navigateurs})", "{n} favoris ({navigateurs})", n).format(
                              n=n, navigateurs=noms) if n else _("aucun favori trouvé (Edge, Chrome, Firefox)"))
        r.add_prefix(self.case_fav)
        g.add(r)
        pref.add(g)
        g = Adw.PreferencesGroup()
        self.ligne_total = Adw.ActionRow(title=_("Place nécessaire"), subtitle=_("calcul en cours…"))
        g.add(self.ligne_total)
        pref.add(g)
        self.btn_copier = self.bouton(_("Copier"), self.copier)
        self.btn_copier.set_sensitive(False)
        self.nav.push(self.page(_("Choix"), pref, "choix", [self.btn_copier]))
        threading.Thread(target=self.mesurer, args=(compte,), daemon=True).start()

    def mesurer(self, compte):
        for cle, _titre, noms, _dest, _defaut in DOSSIERS:
            if self.tailles.get(cle) is not None:
                continue
            nb = total = 0
            for s in sources(compte, noms):
                for _p, _rel, t in fichiers(s):
                    nb += 1
                    total += t
            self.tailles[cle] = (nb, total)
            GLib.idle_add(self.maj_ligne, cle)
        GLib.idle_add(self.maj_total)

    def maj_ligne(self, cle):
        nb, total = self.tailles[cle]
        self.lignes[cle].set_subtitle(ngettext("{taille} · {n} fichier", "{taille} · {n} fichiers", nb).format(
            taille=taille(total), n=nb) if nb else _("dossier vide"))
        if not nb:
            self.cases[cle].set_active(False)
            self.cases[cle].set_sensitive(False)
        self.maj_total()
        return False

    def maj_total(self):
        if any(v is None for v in self.tailles.values()):
            return False
        besoin = sum(self.tailles[c][1] for c, case in self.cases.items() if case.get_active())
        dispo = libre(os.path.expanduser("~"))
        ok = besoin + MARGE <= dispo
        self.ligne_total.set_subtitle(_("{besoin} — place libre : {libre} ✔").format(besoin=taille(besoin),
                                                                                      libre=taille(dispo))
                                      if ok else
                                      _("{besoin} — place libre : {libre} ✘ pas assez de place : décochez des "
                                        "dossiers")
                                      .format(besoin=taille(besoin), libre=taille(dispo)))
        self.btn_copier.set_sensitive(ok and (besoin > 0 or self.case_fav.get_active()))
        return False

    def copier(self):
        choisis = [d for d in DOSSIERS if self.cases[d[0]].get_active()]
        fav = self.case_fav.get_active()
        pref = Adw.PreferencesPage()
        g = Adw.PreferencesGroup()
        st = Adw.StatusPage(icon_name="folder-download-symbolic", title=_("Copie en cours"),
                            description=_("Vous pouvez continuer à utiliser l'ordinateur."))
        st.add_css_class("compact")
        g.add(st)
        self.barre = Gtk.ProgressBar(show_text=True, margin_top=12)
        g.add(self.barre)
        self.etiquette = Gtk.Label(ellipsize=3, margin_top=8, css_classes=["dim-label"])
        g.add(self.etiquette)
        pref.add(g)
        self.arreter = False
        arret = self.bouton(_("Arrêter"), lambda: setattr(self, "arreter", True), "destructive-action")
        p = self.page(_("Copie"), pref, "copie", [arret])
        p.set_can_pop(False)
        self.nav.push(p)
        threading.Thread(target=self.copie, args=(choisis, fav), daemon=True).start()

    def copie(self, choisis, fav):
        total = sum(self.tailles[c[0]][1] for c in choisis) or 1
        fait = copies = deja = 0
        echecs, dests, dernier = [], [], 0
        for cle, titre, noms, dest, _defaut in choisis:
            racine = dest()
            dests.append(racine)
            for s in sources(self.compte, noms):
                for p, rel, t in fichiers(s):
                    if self.arreter:
                        break
                    cible = os.path.join(racine, rel)
                    try:
                        if os.path.exists(cible):
                            if os.path.getsize(cible) == t:
                                deja += 1
                                fait += t
                                continue
                            cible = nom_libre(cible)
                        os.makedirs(os.path.dirname(cible), exist_ok=True)
                        shutil.copyfile(p, cible)
                        st = os.stat(p)
                        os.utime(cible, (st.st_atime, st.st_mtime))
                        copies += 1
                    except OSError as e:
                        # fichiers OneDrive restés « dans le nuage » : illisibles sans Windows
                        echecs.append(f"{titre}/{rel} : {e.strerror or e}")
                        try:
                            if os.path.exists(cible) and os.path.getsize(cible) == 0 and t:
                                os.remove(cible)
                        except OSError:
                            pass
                    fait += t
                    if time.monotonic() - dernier > 0.2:
                        dernier = time.monotonic()
                        GLib.idle_add(self.progression, fait / total, f"{titre} : {rel}")
        fichier_fav = None
        nfav = 0
        if fav and not self.arreter and self.navigateurs:
            fichier_fav = os.path.join(dossier_xdg(GLib.UserDirectory.DIRECTORY_DOCUMENTS, "Documents"),
                                       "Favoris de Windows.html")
            try:
                fichier_fav = ecrire_favoris(self.navigateurs, fichier_fav)
                nfav = sum(compter(a) for _n, a in self.navigateurs)
            except OSError as e:
                echecs.append(_("Favoris : {erreur}").format(erreur=e.strerror or e))
                fichier_fav = None
        GLib.idle_add(self.fin, copies, deja, fait, echecs, fichier_fav, nfav, self.arreter)

    def progression(self, frac, texte):
        self.barre.set_fraction(min(frac, 1))
        self.barre.set_text(f"{frac * 100:.0f} %")
        self.etiquette.set_label(texte)
        return False

    def fin(self, copies, deja, fait, echecs, fichier_fav, nfav, arrete):
        pref = Adw.PreferencesPage()
        g = Adw.PreferencesGroup(title=_("Copie arrêtée") if arrete else _("C'est fait !"))
        g.add(Adw.ActionRow(title=ngettext("{n} fichier copié", "{n} fichiers copiés", copies).format(n=copies),
                            subtitle=(ngettext("{n} déjà présent (non recopié)", "{n} déjà présents (non recopiés)",
                                               deja).format(n=deja) if deja else "")))
        if echecs:
            exp = Adw.ExpanderRow(title=ngettext("{n} fichier non copié", "{n} fichiers non copiés",
                                                 len(echecs)).format(n=len(echecs)),
                                  subtitle=_("Souvent des fichiers OneDrive restés « dans le nuage » : "
                                             "récupérez-les sur onedrive.live.com."))
            for e in echecs[:200]:
                exp.add_row(Adw.ActionRow(title=GLib.markup_escape_text(e), title_lines=3))
            g.add(exp)
        pref.add(g)
        if fichier_fav:
            g = Adw.PreferencesGroup(
                title=ngettext("Favoris : {n} enregistré", "Favoris : {n} enregistrés", nfav).format(n=nfav),
                description=_("Dans <b>{fichier}</b> (dossier Documents). Pour les retrouver dans votre navigateur :\n• "
                              "<b>Brave</b> : menu ☰ → Favoris → Importer des favoris et des paramètres → « Fichier "
                              "HTML de favoris » ;\n• <b>LibreWolf</b> (en anglais) : Ctrl+Maj+O → Import and Backup "
                              "→ Import Bookmarks from HTML.")
                            .format(fichier=GLib.markup_escape_text(os.path.basename(fichier_fav))))
            pref.add(g)
        g = Adw.PreferencesGroup(
            title=_("À savoir"),
            description=_("Les <b>mots de passe</b> enregistrés dans Windows ne peuvent pas être récupérés (ils "
                          "sont verrouillés par Windows). Si vous utilisez un compte Google ou Microsoft dans "
                          "votre navigateur, ils reviendront en vous connectant.\n"
                          "Windows est toujours là, intact."))
        pref.add(g)
        maison = self.bouton(_("Ouvrir mon dossier personnel"), lambda: Gio.AppInfo.launch_default_for_uri(
            GLib.filename_to_uri(os.path.expanduser("~")), None), None)
        suite = self.bouton(_("Équivalents des programmes"), lambda: self.nav.push(self.page_equivalents()))
        self.nav.pop_to_tag("accueil")
        self.nav.push(self.page(_("Terminé"), pref, "fin", [maison, suite]))
        self.fermer_windows()
        return False

    # ---- équivalents ----

    def page_equivalents(self):
        pref = Adw.PreferencesPage(
            description=_("Vos habitudes de Windows et leur équivalent dans KemmOS. Les fichiers Word, Excel, "
                          "PDF, MP3, MP4, JPEG… s'ouvrent d'un double-clic."))
        for section, lignes in EQUIVALENTS:
            g = Adw.PreferencesGroup(title=section)
            for titre, sous, ids, appstream in lignes:
                r = Adw.ActionRow(title=titre, subtitle=sous)
                info = appli(ids) if ids else None
                if info:
                    if info.get_icon():
                        r.add_prefix(Gtk.Image(gicon=info.get_icon(), pixel_size=32))
                    b = Gtk.Button(label=_("Ouvrir"), valign=Gtk.Align.CENTER)
                    b.connect("clicked", lambda _b, i=info: self.lancer(i))
                    r.add_suffix(b)
                elif appstream:
                    r.add_prefix(Gtk.Image(icon_name="system-software-install-symbolic", pixel_size=32))
                    b = Gtk.Button(label=_("Installer"), valign=Gtk.Align.CENTER)
                    b.add_css_class("suggested-action")
                    b.connect("clicked", lambda _b, a=appstream: self.installer(a))
                    r.add_suffix(b)
                else:
                    r.add_prefix(Gtk.Image(icon_name="applications-system-symbolic", pixel_size=32))
                g.add(r)
            pref.add(g)
        return self.page(_("Équivalents des programmes"), pref, "equivalents")

    def lancer(self, info):
        try:
            info.launch([], None)
        except GLib.Error as e:
            self.toast(_("Impossible d'ouvrir : {message}").format(message=e.message))

    def installer(self, appstream):
        try:
            subprocess.Popen(["kemmos-apps", f"--details={appstream}"], start_new_session=True)
        except OSError:
            self.toast(_("KemmOS-Apps (kemmos-apps) introuvable"))

    def fermer_windows(self, *_a):
        # démontage par l'aide sans mot de passe (seulement ce que l'assistant a ouvert)
        if self.point == "/run/kemmos-windows":
            subprocess.Popen(["pkexec", AIDE_FERMER], start_new_session=True,
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        self.point = None
        return False


class Appli(Adw.Application):
    def __init__(self):
        super().__init__(application_id="org.kemmos.Windows", flags=Gio.ApplicationFlags.DEFAULT_FLAGS)

    def do_activate(self):
        fen = self.props.active_window or Assistant(self, "--equivalents" in sys.argv[1:])
        fen.present()


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