#!/usr/bin/python3
# KemmOS-Apps (0.1.0 ; 0.3.0 : traduit en breton et en anglais ; 0.4.0 : applis déjà installées par zypper ;
# 0.5.0 : autorisations en clair et réglables, données effacées au retrait) : logithèque Flathub de KemmOS. Catalogue
# dans la langue de la session classé par catégories, applis
# vérifiées mises en avant, liste d'attente (plusieurs applis choisies puis installées ensemble, un seul mot de
# passe) ou installation directe, applis installées, mises à jour. Installation système (/var/lib/flatpak,
# comme les Flatpaks de l'image) par libflatpak ; les autorisations passent par polkit (actions
# org.freedesktop.Flatpak.* : sans mot de passe pour un administrateur devant l'ordinateur, règle de
# Flatpak ; mot de passe d'un administrateur pour un compte standard).
import json
import hashlib
import os
import shutil
import subprocess
import sys
import threading
import urllib.request

import gi

gi.require_version("Gtk", "4.0")
gi.require_version("Adw", "1")
gi.require_version("Flatpak", "1.0")
from gi.repository import Adw, Flatpak, Gdk, Gio, GLib, GObject, 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

sys.path.insert(0, "/usr/share/kemmos-apps")
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))   # essais depuis le dossier des sources
import autorisations  # noqa: E402
import catalogue  # noqa: E402
import gettext  # noqa: E402


class _Francais(gettext.NullTranslations):
    """Textes d'origine (français) : pluriel à partir de 2, « 0 résultat »."""

    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-apps")
_, ngettext = _trad.gettext, _trad.ngettext
# Textes AppStream (noms, résumés, descriptions) : langue de la session, puis français pour le breton,
# puis anglais (balises sans xml:lang)
LANGUES_APPSTREAM = ("br", "fr", "") if LANGUE == "br" else (LANGUE, "")

APP_ID = "org.kemmos.Apps"
VERSION = "0.5.0"
REMOTE = "flathub"
ARCH = Flatpak.get_default_arch()
APPSTREAM = f"/var/lib/flatpak/appstream/{REMOTE}/{ARCH}/active"
LOGO = "/usr/share/icons/kemmos/kemmos-logo.png"   # médaillon caméléon + Tux (make-branding.py)
CACHE = os.path.join(GLib.get_user_cache_dir(), "kemmos-apps")
CONFIG = os.path.join(GLib.get_user_config_dir(), "kemmos-apps", "reglages.json")
AGE_APPSTREAM = 6 * 3600   # catalogue rafraîchi à l'ouverture s'il a plus de 6 heures
PAR_PAGE = 48              # cartes affichées d'un coup dans une catégorie (puis « Afficher plus »)

CSS = """
:root { --accent-bg-color: #2e7d32; --accent-fg-color: #ffffff; --accent-color: #2e7d32; }
@media (prefers-color-scheme: dark) { :root { --accent-color: #81c784; } }
.hero { background: linear-gradient(135deg, #1b5e20, #2e7d32 55%, #66bb6a); color: #ffffff;
        border-radius: 18px; padding: 22px 26px; }
.hero .titre { font-size: 26pt; font-weight: 800; }
.hero .sous-titre { font-size: 12pt; opacity: 0.92; }
.hero entry { background: rgba(255,255,255,0.95); color: #1d2621; min-height: 40px; border-radius: 10px; }
.tuile { background: alpha(#43a047, 0.12); border-radius: 14px; padding: 14px 16px; min-width: 190px; }
.tuile:hover { background: alpha(#43a047, 0.22); }
.tuile image { color: #2e7d32; }
.tuile .compte { opacity: 0.6; font-size: 9pt; }
.carte-app { padding: 12px; min-width: 300px; }
.verifie { color: #2e7d32; font-weight: bold; font-size: 9pt; }
.systeme { color: #1565c0; font-weight: bold; font-size: 9pt; }
.systeme-pastille { background: alpha(#1e88e5, 0.15); }
@media (prefers-color-scheme: dark) { .verifie, .tuile image { color: #81c784; } .systeme { color: #90caf9; } }
.pastille { background: alpha(#43a047, 0.15); border-radius: 99px; padding: 2px 10px; font-size: 9pt; }
.proprio { background: alpha(#ef6c00, 0.15); }
.compteur { background: #2e7d32; color: #ffffff; border-radius: 99px; padding: 0 7px; font-size: 9pt;
            font-weight: bold; min-width: 12px; }
.capture { border-radius: 10px; }
"""


def lire_reglages():
    try:
        with open(CONFIG) as f:
            d = json.load(f)
        return d if isinstance(d, dict) else {}
    except (OSError, ValueError):
        return {}


def ecrire_reglages(d):
    try:
        os.makedirs(os.path.dirname(CONFIG), exist_ok=True)
        with open(CONFIG + ".tmp", "w") as f:
            json.dump(d, f)
        os.replace(CONFIG + ".tmp", CONFIG)
    except OSError:
        pass


def taille_lisible(n):
    for unite in ("o", "Ko", "Mo", "Go"):
        if n < 1024 or unite == "Go":
            return f"{n:.0f} {unite}" if unite == "o" else f"{n:.1f} {unite}".replace(".", ",")
        n /= 1024


def donnees_app(i):
    """Dossier des réglages et données d'une application Flatpak (~/.var/app/<id>)."""
    return os.path.join(os.path.expanduser("~/.var/app"), i)


def taille_dossier(chemin):
    total = 0
    for racine, _d, fichiers in os.walk(chemin):
        for f in fichiers:
            try:
                total += os.lstat(os.path.join(racine, f)).st_size
            except OSError:
                pass
    return total


def message_erreur(e):
    """Texte compréhensible pour une erreur de flatpak (GLib.Error)."""
    m = getattr(e, "message", None) or str(e)
    bas = m.lower()
    if "not authorized" in bas or "authorization" in bas or "dismissed" in bas or "cancel" in bas:
        return _("Autorisation refusée : rien n'a été modifié.")
    if "no space" in bas:
        return _("Plus assez de place sur le disque.")
    if "could not resolve" in bas or "while fetching" in bas or "network" in bas or "timeout" in bas:
        return _("Flathub ne répond pas : vérifiez la connexion à Internet, puis réessayez.") + "\n\n(" + m + ")"
    return m


class Moteur:
    """Accès à l'installation Flatpak système (à n'utiliser que depuis un fil de travail, pas l'interface)."""

    def __init__(self):
        self.inst = Flatpak.Installation.new_system(None)

    def installees(self):
        return {r.get_name(): r for r in self.inst.list_installed_refs_by_kind(Flatpak.RefKind.APP, None)}

    def metadata_distante(self, ref):
        """Fichier metadata d'une application pas encore installée (autorisations demandées)."""
        b = self.inst.fetch_remote_metadata_sync(REMOTE, Flatpak.Ref.parse(ref), None)
        return bytes(b.get_data()).decode("utf-8", "replace")

    @staticmethod
    def installees_utilisateur():
        try:
            return {r.get_name() for r in Flatpak.Installation.new_user(None)
                    .list_installed_refs_by_kind(Flatpak.RefKind.APP, None)}
        except GLib.Error:
            return set()

    def a_mettre_a_jour(self):
        return list(self.inst.list_installed_refs_for_update(None))

    def inutilises(self):
        try:
            return list(self.inst.list_unused_refs(None, None))
        except (GLib.Error, AttributeError):
            return []

    def rafraichir_catalogue(self, forcer=False):
        """Télécharge l'AppStream de Flathub s'il est absent ou vieux (sans mot de passe : appstream-update)."""
        src = os.path.join(APPSTREAM, "appstream.xml.gz")
        try:
            age = GLib.get_real_time() / 1e6 - os.stat(src).st_mtime
        except OSError:
            age = None
        if forcer or age is None or age > AGE_APPSTREAM:
            try:
                self.inst.update_appstream_sync(REMOTE, None, None)
            except GLib.Error:
                if age is None:
                    raise

    def executer(self, operations, sur_progres, annulation):
        """operations : liste de (genre, ref, nom) avec genre install/update/uninstall. Bloquant."""
        t = Flatpak.Transaction.new_for_installation(self.inst, None)
        noms = {}
        for genre, ref, nom in operations:
            noms[ref] = nom
            if genre == "install":
                t.add_install(REMOTE, ref, None)
            elif genre == "update":
                t.add_update(ref, None, None)
            else:
                t.add_uninstall(ref)
        etat = {"n": 0, "total": 1, "erreurs": []}

        def pret(tr):
            etat["total"] = max(1, len(tr.get_operations()))
            return True

        def nouvelle(tr, op, progres):
            etat["n"] += 1
            ref = op.get_ref()
            nom = noms.get(ref) or ref.split("/")[1]
            genre = op.get_operation_type()
            if not ref.startswith("app/"):
                nom = _("{nom} (composant commun)").format(nom=nom)
            n, total = etat["n"], etat["total"]
            texte = {Flatpak.TransactionOperationType.INSTALL: _("Installation de {nom} ({n}/{total})"),
                     Flatpak.TransactionOperationType.UPDATE: _("Mise à jour de {nom} ({n}/{total})"),
                     Flatpak.TransactionOperationType.UNINSTALL: _("Retrait de {nom} ({n}/{total})")
                     }.get(genre, _("Opération sur {nom} ({n}/{total})")).format(nom=nom, n=n, total=total)
            progres.set_update_frequency(200)
            progres.connect("changed", lambda p: sur_progres(texte, (n - 1 + p.get_progress() / 100) / total))
            sur_progres(texte, (n - 1) / total)

        def erreur(tr, op, err, details):
            etat["erreurs"].append(f"{op.get_ref().split('/')[1]} : {message_erreur(err)}")
            return True   # continuer avec les autres applis de la liste

        t.connect("ready", pret)
        t.connect("new-operation", nouvelle)
        t.connect("operation-error", erreur)
        t.run(annulation)
        return etat["erreurs"]


class CarteApp(Gtk.FlowBoxChild):
    """Carte d'une appli : icône, nom, résumé, badge vérifié, boutons Installer / liste d'attente / Ouvrir."""

    def __init__(self, fen, app):
        super().__init__()
        self.fen, self.app = fen, app
        boite = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=12)
        boite.add_css_class("card")
        boite.add_css_class("carte-app")
        boite.append(fen.icone(app, 64))
        txt = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3, hexpand=True, valign=Gtk.Align.CENTER)
        nom = Gtk.Label(label=app["nom"], xalign=0, ellipsize=3)
        nom.add_css_class("heading")
        txt.append(nom)
        res = Gtk.Label(label=app["resume"], xalign=0, wrap=True, lines=2, ellipsize=3, max_width_chars=34)
        res.add_css_class("dim-label")
        txt.append(res)
        if app["verifie"]:
            v = Gtk.Label(label=_("✓ Vérifiée"), xalign=0)
            v.add_css_class("verifie")
            txt.append(v)
        self.etat = Gtk.Label(label=_("Installée par le système (zypper)"), xalign=0, visible=False)
        self.etat.add_css_class("systeme")
        txt.append(self.etat)
        boite.append(txt)
        self.boutons = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6, valign=Gtk.Align.CENTER)
        boite.append(self.boutons)
        self.set_child(boite)
        self.actualiser()

    def actualiser(self):
        self.etat.set_visible(self.app["id"] not in self.fen.installees and
                              self.fen.lanceur_rpm(self.app["id"]) is not None)
        while (b := self.boutons.get_first_child()) is not None:
            self.boutons.remove(b)
        for b in self.fen.boutons_app(self.app, compact=True):
            self.boutons.append(b)


class Fenetre(Adw.ApplicationWindow):
    def __init__(self, application):
        super().__init__(application=application, title="KemmOS-Apps", default_width=1180, default_height=820)
        self.set_size_request(380, 500)
        self.moteur = None
        self.apps = []            # catalogue (dicts de catalogue.py), trié par nom
        self.par_id = {}
        self.pop = {}             # popularité : installations Flathub du dernier mois
        self.installees = {}      # id → Flatpak.InstalledRef
        self.systeme = {}         # applis installées par paquet (zypper) : voir catalogue.applis_systeme
        self.maj = []             # Flatpak.InstalledRef à mettre à jour
        self.reglages = lire_reglages()
        self.attente = [i for i in self.reglages.get("attente", []) if isinstance(i, str)]
        self.occupe = False
        self.annulation = None
        self.cartes = []          # cartes affichées (pour rafraîchir leurs boutons)
        self.fiches_boutons = []  # fiches ouvertes : fonctions qui redessinent leurs boutons
        self.lignes_installees, self.lignes_maj = [], []
        self.inutiles = []        # composants (runtimes) qui ne servent plus
        self.fiche_demandee = None  # identifiant à ouvrir dès que le catalogue est prêt (--details, .flatpakref)

        self.toasts = Adw.ToastOverlay()
        self.split = Adw.OverlaySplitView(sidebar_position=Gtk.PackType.END, show_sidebar=False,
                                          max_sidebar_width=380, min_sidebar_width=300)
        self.toasts.set_child(self.split)
        self.set_content(self.toasts)
        self.nav = Adw.NavigationView()
        self.split.set_content(self.nav)
        self.split.set_sidebar(self.panneau_attente())

        # Barre de progression commune à toutes les pages (installation en cours)
        self.barre = Gtk.Revealer(transition_type=Gtk.RevealerTransitionType.SLIDE_UP)
        b = Gtk.Box(spacing=12, margin_start=16, margin_end=16, margin_top=8, margin_bottom=8)
        bb = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=4, hexpand=True)
        self.barre_texte = Gtk.Label(xalign=0, ellipsize=3)
        self.barre_progres = Gtk.ProgressBar()
        bb.append(self.barre_texte)
        bb.append(self.barre_progres)
        b.append(bb)
        self.bouton_annuler = Gtk.Button(label=_("Annuler"), valign=Gtk.Align.CENTER)
        self.bouton_annuler.connect("clicked", lambda *_: self.annulation and self.annulation.cancel())
        b.append(self.bouton_annuler)
        self.barre.set_child(b)

        self.nav.add(self.page_principale())
        self.chargement_initial()

    # ---------- outils d'interface ----------

    def icone(self, app, taille):
        img = Gtk.Image(pixel_size=taille)
        ic = app.get("icone") if app else None
        chemin = os.path.join(APPSTREAM, "icons", f"{ic[0]}x{ic[0]}", ic[1]) if ic else None
        if chemin and os.path.exists(chemin):
            img.set_from_file(chemin)
        else:
            theme = Gtk.IconTheme.get_for_display(Gdk.Display.get_default())
            nom = app["id"] if app else None
            img.set_from_icon_name(nom if nom and theme.has_icon(nom) else "application-x-executable")
        return img

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

    def alerte(self, titre, corps):
        d = Adw.AlertDialog(heading=titre, body=corps)
        d.add_response("ok", "OK")
        d.present(self)

    def boutons_app(self, app, compact=False):
        """Boutons selon l'état de l'appli : Ouvrir/Retirer, ou Installer + liste d'attente."""
        i = app["id"]
        res = []
        if i in self.installees:
            o = Gtk.Button(label=_("Ouvrir"))
            o.connect("clicked", lambda *_: self.ouvrir(i))
            res.append(o)
            if not compact:
                r = Gtk.Button(label=_("Retirer"))
                r.add_css_class("destructive-action")
                r.connect("clicked", lambda *_: self.demander_retrait(i))
                res.append(r)
            return res
        lanceur = self.lanceur_rpm(i)
        if lanceur:
            # déjà installée par un paquet du système (zypper) : l'ouvrir ; la version Flathub reste
            # installable depuis la fiche
            o = Gtk.Button(label=_("Ouvrir"), tooltip_text=_("Installée par le système (zypper)"))
            o.connect("clicked", lambda *_: self.ouvrir_lanceur(lanceur))
            res.append(o)
            if compact:
                return res
            inst = Gtk.Button(label=_("Installer aussi la version Flathub"))
            inst.set_sensitive(not self.occupe)
            inst.connect("clicked", lambda *_: self.installer([i]))
            res.append(inst)
            return res
        inst = Gtk.Button(label=_("Installer"), tooltip_text=_("Installer tout de suite"))
        inst.add_css_class("suggested-action")
        inst.set_sensitive(not self.occupe)
        inst.connect("clicked", lambda *_: self.installer([i]))
        res.append(inst)
        dans = i in self.attente
        if compact:
            att = Gtk.Button(icon_name="object-select-symbolic" if dans else "list-add-symbolic",
                             tooltip_text=_("Retirer de la liste d'attente") if dans else
                             _("Ajouter à la liste d'attente (installer plus tard, avec d'autres)"))
        else:
            att = Gtk.Button(label=_("Dans la liste d'attente ✓") if dans else _("Ajouter à la liste d'attente"))
        att.connect("clicked", lambda *_: self.basculer_attente(i))
        res.append(att)
        return res

    def lanceur_rpm(self, i):
        return catalogue.lanceur_systeme(self.systeme, i)

    def grille(self):
        g = Gtk.FlowBox(selection_mode=Gtk.SelectionMode.NONE, homogeneous=True, max_children_per_line=4,
                        min_children_per_line=1, column_spacing=12, row_spacing=12,
                        activate_on_single_click=True, valign=Gtk.Align.START)
        g.connect("child-activated", lambda _g, c: self.ouvrir_fiche(c.app))
        return g

    def remplir(self, grille, apps):
        while (c := grille.get_first_child()) is not None:
            grille.remove(c)
        for a in apps:
            c = CarteApp(self, a)
            grille.append(c)
            self.cartes.append(c)

    def titre_section(self, texte, sous=None):
        b = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2, margin_top=10)
        t = Gtk.Label(label=texte, xalign=0)
        t.add_css_class("title-3")
        b.append(t)
        if sous:
            s = Gtk.Label(label=sous, xalign=0, wrap=True)
            s.add_css_class("dim-label")
            b.append(s)
        return b

    def page_defilante(self, contenu, largeur=1200):
        sw = Gtk.ScrolledWindow(hscrollbar_policy=Gtk.PolicyType.NEVER, vexpand=True)
        cl = Adw.Clamp(maximum_size=largeur, margin_start=16, margin_end=16, margin_top=16, margin_bottom=24)
        cl.set_child(contenu)
        sw.set_child(cl)
        return sw

    def visibles(self, apps):
        """Filtre « vérifiées seulement » puis tri par popularité (ordre alphabétique sans réseau)."""
        if self.reglages.get("verifiees", True):
            apps = [a for a in apps if a["verifie"]]
        if self.pop:
            apps = sorted(apps, key=lambda a: -self.pop.get(a["id"], 0))
        return apps

    # ---------- page principale : Découvrir / Installées / Mises à jour ----------

    def page_principale(self):
        tv = Adw.ToolbarView()
        hb = Adw.HeaderBar()
        self.pile = Adw.ViewStack()
        sw = Adw.ViewSwitcher(stack=self.pile, policy=Adw.ViewSwitcherPolicy.WIDE)
        hb.set_title_widget(sw)
        # Bouton de la liste d'attente (avec le nombre d'applis choisies)
        self.bouton_attente = Gtk.ToggleButton(tooltip_text=_("Liste d'attente"))
        ba = Gtk.Box(spacing=6)
        ba.append(Gtk.Image(icon_name="view-list-bullet-symbolic"))
        ba.append(Gtk.Label(label=_("Liste d'attente")))
        self.compteur = Gtk.Label(label="0", visible=False)
        self.compteur.add_css_class("compteur")
        ba.append(self.compteur)
        self.bouton_attente.set_child(ba)
        self.bouton_attente.bind_property("active", self.split, "show-sidebar",
                                          GObject.BindingFlags.BIDIRECTIONAL)
        hb.pack_end(self.bouton_attente)
        menu = Gio.Menu()
        menu.append(_("Actualiser le catalogue"), "win.actualiser")
        menu.append(_("À propos de KemmOS-Apps"), "win.apropos")
        hb.pack_end(Gtk.MenuButton(icon_name="open-menu-symbolic", menu_model=menu, tooltip_text=_("Menu")))
        for nom, fn in (("actualiser", lambda *_: self.chargement_initial(forcer=True)),
                        ("apropos", lambda *_: self.a_propos())):
            act = Gio.SimpleAction.new(nom, None)
            act.connect("activate", fn)
            self.add_action(act)
        tv.add_top_bar(hb)
        # Fenêtre étroite : onglets en bas, titre seul en haut
        bas = Adw.ViewSwitcherBar(stack=self.pile)
        bp = Adw.Breakpoint.new(Adw.BreakpointCondition.parse("max-width: 700sp"))
        bp.add_setter(bas, "reveal", True)
        bp.add_setter(hb, "title-widget", Adw.WindowTitle(title="KemmOS-Apps"))
        self.add_breakpoint(bp)
        tv.add_bottom_bar(self.barre)
        tv.add_bottom_bar(bas)
        tv.set_content(self.pile)

        self.pile.add_titled_with_icon(self.page_decouvrir(), "decouvrir", _("Découvrir"), "system-search-symbolic")
        self.pile.add_titled_with_icon(self.page_installees(), "installees", _("Installées"),
                                       "emblem-default-symbolic")
        p = self.pile.add_titled_with_icon(self.page_maj(), "maj", _("Mises à jour"), "software-update-available-symbolic")
        self.page_pile_maj = p
        self.pile.connect("notify::visible-child-name", lambda *_: self.sur_onglet())
        return Adw.NavigationPage(title="KemmOS-Apps", child=tv, tag="accueil")

    def page_decouvrir(self):
        self.decouvrir = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        # Bandeau d'accueil : logo KemmOS (caméléon + Tux), titre, recherche
        hero = Gtk.Box(spacing=22)
        hero.add_css_class("hero")
        if os.path.exists(LOGO):
            logo = Gtk.Picture.new_for_filename(LOGO)
            logo.set_size_request(112, 112)
            logo.set_can_shrink(True)
            logo.set_content_fit(Gtk.ContentFit.CONTAIN)
        else:
            logo = Gtk.Image(icon_name="kemmos", pixel_size=112)
        logo.set_valign(Gtk.Align.CENTER)
        hero.append(logo)
        ht = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6, hexpand=True, valign=Gtk.Align.CENTER)
        t = Gtk.Label(label="KemmOS-Apps", xalign=0)
        t.add_css_class("titre")
        ht.append(t)
        st = Gtk.Label(label=_("Des milliers d'applications de Flathub. Installez-en une tout de suite, ou "
                               "ajoutez-en plusieurs à la liste d'attente : elles s'installeront ensemble."),
                       xalign=0, wrap=True)
        st.add_css_class("sous-titre")
        ht.append(st)
        self.recherche = Gtk.SearchEntry(placeholder_text=_("Rechercher une application (nom, usage : « dessin », "
                                                            "« montage vidéo »…)"), margin_top=6)
        self.recherche.connect("search-changed", lambda *_: self.sur_recherche())
        ht.append(self.recherche)
        hero.append(ht)
        self.decouvrir.append(hero)

        # Filtre des applis vérifiées
        ligne = Gtk.Box(spacing=10)
        self.inter_verif = Gtk.Switch(active=self.reglages.get("verifiees", True), valign=Gtk.Align.CENTER)
        self.inter_verif.connect("notify::active", lambda *_: self.sur_filtre())
        ligne.append(self.inter_verif)
        lv = Gtk.Label(label=_("Applications vérifiées seulement"), xalign=0)
        lv.add_css_class("heading")
        ligne.append(lv)
        aide = Gtk.Label(label=_("publiées par leurs auteurs eux-mêmes (✓ vérifiée par Flathub)"), xalign=0,
                         wrap=True, hexpand=True)
        aide.add_css_class("dim-label")
        ligne.append(aide)
        self.decouvrir.append(ligne)

        # Résultats de recherche (cachés sans recherche) et sections de l'accueil
        self.resultats = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10, visible=False)
        self.resultats_titre = self.titre_section(_("Résultats"))
        self.resultats.append(self.resultats_titre)
        self.grille_resultats = self.grille()
        self.resultats.append(self.grille_resultats)
        self.decouvrir.append(self.resultats)

        self.sections = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        self.sections.append(self.titre_section(_("Catégories")))
        self.tuiles = Gtk.FlowBox(selection_mode=Gtk.SelectionMode.NONE, homogeneous=True,
                                  max_children_per_line=6, min_children_per_line=2, column_spacing=10,
                                  row_spacing=10, activate_on_single_click=True)
        self.tuiles.connect("child-activated", lambda _f, c: self.ouvrir_categorie(c.cat))
        self.sections.append(self.tuiles)
        self.sections.append(self.titre_section(_("Sélection KemmOS"), _("Des valeurs sûres pour bien démarrer")))
        self.grille_selection = self.grille()
        self.sections.append(self.grille_selection)
        self.sections.append(self.titre_section(_("Les plus installées"), _("Le mois dernier, sur Flathub")))
        self.grille_populaires = self.grille()
        self.sections.append(self.grille_populaires)
        self.decouvrir.append(self.sections)

        self.chargement = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12, margin_top=40)
        self.chargement.append(Adw.Spinner(height_request=48))
        self.chargement_texte = Gtk.Label(label=_("Lecture du catalogue Flathub…"))
        self.chargement_texte.add_css_class("dim-label")
        self.chargement.append(self.chargement_texte)
        self.decouvrir.append(self.chargement)
        self.sections.set_visible(False)
        return self.page_defilante(self.decouvrir)

    def remplir_accueil(self):
        self.cartes = []
        while (c := self.tuiles.get_first_child()) is not None:
            self.tuiles.remove(c)
        for ident, nom, icone, _fd in catalogue.CATEGORIES:
            n = len(self.visibles([a for a in self.apps if ident in a["categories"]]))
            c = Gtk.FlowBoxChild()
            c.cat = ident
            b = Gtk.Box(spacing=12)
            b.add_css_class("tuile")
            b.append(Gtk.Image(icon_name=icone, pixel_size=28))
            bt = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, valign=Gtk.Align.CENTER)
            lb = Gtk.Label(label=_(nom), xalign=0)
            lb.add_css_class("heading")
            bt.append(lb)
            cp = Gtk.Label(label=ngettext("{n} application", "{n} applications", n).format(n=n), xalign=0)
            cp.add_css_class("compte")
            bt.append(cp)
            b.append(bt)
            c.set_child(b)
            self.tuiles.append(c)
        sel = [self.par_id[i] for i in catalogue.SELECTION if i in self.par_id]
        self.remplir(self.grille_selection, sel[:12])
        if self.pop:
            self.remplir(self.grille_populaires, self.visibles(self.apps)[:12])
        self.grille_populaires.get_prev_sibling().set_visible(bool(self.pop))
        self.grille_populaires.set_visible(bool(self.pop))
        self.sur_recherche()

    def sur_recherche(self):
        texte = self.recherche.get_text().strip()
        cherche = bool(texte) and bool(self.apps)
        self.resultats.set_visible(cherche)
        self.sections.set_visible(not cherche and bool(self.apps))
        if not cherche:
            return
        res = catalogue.chercher(self.apps, texte)
        if self.reglages.get("verifiees", True):
            caches = sum(1 for a in res if not a["verifie"])
            res = [a for a in res if a["verifie"]]
        else:
            caches = 0
        lbl = self.resultats_titre.get_first_child()
        titre = ngettext("{n} résultat", "{n} résultats", len(res)).format(n=len(res))
        if caches:
            titre += " " + ngettext("(et {n} non vérifiée : désactivez le filtre pour la voir)",
                                    "(et {n} non vérifiées : désactivez le filtre pour les voir)",
                                    caches).format(n=caches)
        lbl.set_label(titre)
        self.remplir(self.grille_resultats, res[:60])

    def sur_filtre(self):
        self.reglages["verifiees"] = self.inter_verif.get_active()
        ecrire_reglages(self.reglages)
        if self.apps:
            self.remplir_accueil()

    # ---------- catégorie, fiche ----------

    def ouvrir_categorie(self, ident):
        apps = self.visibles([a for a in self.apps if ident in a["categories"]])
        boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        verif = self.reglages.get("verifiees", True)
        n = len(apps)
        if verif and self.pop:
            sous = ngettext("{n} application, vérifiée, les plus installées d'abord",
                            "{n} applications, vérifiées, les plus installées d'abord", n)
        elif verif:
            sous = ngettext("{n} application, vérifiée", "{n} applications, vérifiées", n)
        elif self.pop:
            sous = ngettext("{n} application, les plus installées d'abord",
                            "{n} applications, les plus installées d'abord", n)
        else:
            sous = ngettext("{n} application", "{n} applications", n)
        boite.append(self.titre_section(_(catalogue.NOMS_CATEGORIES[ident]), sous.format(n=n)))
        g = self.grille()
        boite.append(g)
        plus = Gtk.Button(label=_("Afficher plus"), halign=Gtk.Align.CENTER)
        plus.add_css_class("pill")
        boite.append(plus)
        etat = {"n": 0}

        def suite(*_):
            for a in apps[etat["n"]:etat["n"] + PAR_PAGE]:
                c = CarteApp(self, a)
                g.append(c)
                self.cartes.append(c)
            etat["n"] += PAR_PAGE
            plus.set_visible(etat["n"] < len(apps))
        plus.connect("clicked", suite)
        suite()
        tv = Adw.ToolbarView()
        tv.add_top_bar(Adw.HeaderBar())
        tv.set_content(self.page_defilante(boite))
        self.nav.push(Adw.NavigationPage(title=_(catalogue.NOMS_CATEGORIES[ident]), child=tv))

    def ouvrir_fiche(self, app):
        boite = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=18)
        tete = Gtk.Box(spacing=20)
        tete.append(self.icone(app, 128))
        tt = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6, valign=Gtk.Align.CENTER, hexpand=True)
        n = Gtk.Label(label=app["nom"], xalign=0, wrap=True)
        n.add_css_class("title-1")
        tt.append(n)
        if app["developpeur"]:
            d = Gtk.Label(label=app["developpeur"], xalign=0)
            d.add_css_class("dim-label")
            tt.append(d)
        if app["verifie"]:
            v = Gtk.Label(label=_("✓ Vérifiée : publiée par son auteur"), xalign=0)
            v.add_css_class("verifie")
            tt.append(v)
        r = Gtk.Label(label=app["resume"], xalign=0, wrap=True)
        tt.append(r)
        boutons = Gtk.Box(spacing=8, margin_top=6)
        tt.append(boutons)
        tete.append(tt)
        boite.append(tete)

        def maj_boutons():
            while (b := boutons.get_first_child()) is not None:
                boutons.remove(b)
            for b in self.boutons_app(app):
                b.add_css_class("pill")
                boutons.append(b)
        maj_boutons()
        self.fiches_boutons.append(maj_boutons)

        # Pastilles : version, licence, site
        info = Gtk.Box(spacing=8)
        if app["version"]:
            info.append(self.pastille(
                _("Version {version} du {date}").format(version=app["version"], date=app["date"]) if app["date"]
                else _("Version {version}").format(version=app["version"])))
        if app["id"] not in self.installees and self.lanceur_rpm(app["id"]):
            p = self.pastille(_("Déjà installée par le système (paquet zypper)"))
            p.add_css_class("systeme-pastille")
            info.append(p)
        if app["libre"] is False:
            p = self.pastille(_("Logiciel propriétaire"))
            p.add_css_class("proprio")
            info.append(p)
        elif app["libre"]:
            info.append(self.pastille(_("Logiciel libre")))
        if app["site"].startswith(("https://", "http://")):
            lien = Gtk.LinkButton(uri=app["site"], label=_("Site du projet"))
            info.append(lien)
        boite.append(info)

        if app["captures"]:
            car = Adw.Carousel(spacing=12, allow_scroll_wheel=False, height_request=420)
            for cap in app["captures"]:
                pic = Gtk.Picture(content_fit=Gtk.ContentFit.CONTAIN, can_shrink=True, hexpand=True)
                pic.add_css_class("capture")
                if cap["legende"]:
                    pic.set_tooltip_text(cap["legende"])
                car.append(pic)
                self.charger_capture(cap["url"], pic)
            boite.append(car)
            if len(app["captures"]) > 1:
                nav = Gtk.Box(spacing=6, halign=Gtk.Align.CENTER)
                prec = Gtk.Button(icon_name="go-previous-symbolic")
                suiv = Gtk.Button(icon_name="go-next-symbolic")
                for b in (prec, suiv):
                    b.add_css_class("circular")

                def aller(_b, delta):
                    i = min(max(round(car.get_position()) + delta, 0), car.get_n_pages() - 1)
                    car.scroll_to(car.get_nth_page(i), True)
                prec.connect("clicked", aller, -1)
                suiv.connect("clicked", aller, 1)
                nav.append(prec)
                nav.append(Adw.CarouselIndicatorDots(carousel=car))
                nav.append(suiv)
                boite.append(nav)

        if app["description"]:
            boite.append(self.titre_section(_("Description")))
            d = Gtk.Label(label=app["description"], xalign=0, wrap=True, selectable=True)
            boite.append(d)
        details = Gtk.Label(label=_("Identifiant Flathub : {id}").format(id=app["id"]) +
                                  ("\n" + _("Licence : {licence}").format(licence=app["licence"])
                                   if app["licence"] else ""),
                            xalign=0, selectable=True, wrap=True)
        details.add_css_class("dim-label")
        boite.append(details)
        boite.append(self.groupe_autorisations(app))

        tv = Adw.ToolbarView()
        tv.add_top_bar(Adw.HeaderBar())
        tv.set_content(self.page_defilante(boite, 980))
        page = Adw.NavigationPage(title=app["nom"], child=tv)
        page.connect("hidden", lambda *_: maj_boutons in self.fiches_boutons and
                     self.fiches_boutons.remove(maj_boutons))
        self.nav.push(page)

    # ---------- autorisations (0.5.0) ----------

    def groupe_autorisations(self, app):
        i = app["id"]
        g = Adw.PreferencesGroup(title=_("Autorisations"))
        attente = Adw.ActionRow(title=_("Lecture des autorisations…"))
        g.add(attente)
        ref = self.installees.get(i)

        def afficher(texte):
            g.remove(attente)
            base = autorisations.lire_contexte(texte)
            if ref is None:
                g.set_description(_("Ce que l'application pourra atteindre une fois installée."))
                self.lignes_autorisations(g, i, base, None)
            else:
                g.set_description(_("Ce que l'application peut atteindre. Vous pouvez retirer un accès : certaines "
                                    "de ses fonctions peuvent alors ne plus marcher."))
                self.lignes_autorisations(g, i, base, autorisations.fusionner(base, autorisations.lire_surcharge(i)))
            return False

        def echec(msg):
            attente.set_title(_("Autorisations inconnues"))
            attente.set_subtitle(msg)
            return False

        if ref is not None:
            try:
                afficher(bytes(ref.load_metadata(None).get_data()).decode("utf-8", "replace"))
            except GLib.Error as e:
                echec(message_erreur(e))
        elif self.moteur and app.get("ref"):
            def travail():
                try:
                    texte = self.moteur.metadata_distante(app["ref"])
                    GLib.idle_add(afficher, texte)
                except GLib.Error as e:
                    GLib.idle_add(echec, message_erreur(e))
            threading.Thread(target=travail, daemon=True).start()
        else:
            echec("")
        return g

    def lignes_autorisations(self, g, i, base, effectif):
        """effectif None : application pas installée (lecture seule)."""
        vues = autorisations.lisibles(effectif if effectif is not None else base, _)
        # autorisations réglables retirées par l'utilisateur : affichées aussi, interrupteur éteint
        if effectif is not None:
            presents = {(c, v) for c, v, *_r in vues}
            for c, v, texte, niveau, ro in autorisations.lisibles(base, _):
                if (c, v) in autorisations.REGLABLES and (c, v) not in presents:
                    vues.append((c, v, texte, niveau, ro))
        if not vues:
            g.add(Adw.ActionRow(title=_("Aucun accès particulier"),
                                subtitle=_("L'application reste isolée du reste de l'ordinateur")))
            return
        symboles = {3: ("⚠", "warning"), 2: ("●", "accent"), 1: ("✓", "success")}
        for c, v, texte, niveau, _ro in vues:
            if effectif is not None and (c, v) in autorisations.REGLABLES:
                actif = any(x.split(":")[0] == v for x in effectif.get(c, []))
                r = Adw.SwitchRow(title=GLib.markup_escape_text(texte), active=actif)
                r.connect("notify::active", lambda sw, _p, c=c, v=v: self.regler_autorisation(i, c, v, sw))
            else:
                r = Adw.ActionRow(title=GLib.markup_escape_text(texte))
            sym, css = symboles[niveau]
            p = Gtk.Label(label=sym)
            p.add_css_class(css)
            r.add_prefix(p)
            g.add(r)
        if effectif is not None and os.path.exists(os.path.join(autorisations.OVERRIDES, i)):
            b = Gtk.Button(label=_("Rétablir les autorisations d'origine"), valign=Gtk.Align.CENTER)
            b.connect("clicked", lambda _b: (autorisations.retablir(i), self.toast(_("Autorisations d'origine "
                                                                                    "rétablies"))))
            g.set_header_suffix(b)

    def regler_autorisation(self, i, cle, valeur, interrupteur):
        ok, msg = autorisations.regler(i, cle, valeur, interrupteur.get_active())
        if ok:
            self.toast(_("Accès rendu : effet au prochain lancement de l'application") if interrupteur.get_active()
                       else _("Accès retiré : effet au prochain lancement de l'application"))
        else:
            self.toast(_("Réglage impossible : {erreur}").format(erreur=msg))

    def pastille(self, texte):
        l = Gtk.Label(label=texte)
        l.add_css_class("pastille")
        return l

    def charger_capture(self, url, pic):
        """Capture d'écran téléchargée en arrière-plan, gardée dans ~/.cache/kemmos-apps/captures."""
        if not url.startswith(catalogue.MEDIA):
            return
        dossier = os.path.join(CACHE, "captures")
        fichier = os.path.join(dossier, hashlib.sha1(url.encode()).hexdigest() + os.path.splitext(url)[1][:5])

        def travail():
            if not os.path.exists(fichier):
                try:
                    os.makedirs(dossier, exist_ok=True)
                    req = urllib.request.Request(url, headers={"User-Agent": "KemmOS-Apps"})
                    with urllib.request.urlopen(req, timeout=20) as r:
                        data = r.read(8 * 1024 * 1024)
                    with open(fichier + ".tmp", "wb") as f:
                        f.write(data)
                    os.replace(fichier + ".tmp", fichier)
                except OSError:
                    return
            GLib.idle_add(lambda: pic.set_filename(fichier) and False)
        threading.Thread(target=travail, daemon=True).start()

    # ---------- liste d'attente ----------

    def panneau_attente(self):
        tv = Adw.ToolbarView()
        hb = Adw.HeaderBar(show_title=True)
        hb.set_title_widget(Adw.WindowTitle(title=_("Liste d'attente")))
        tv.add_top_bar(hb)
        b = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12, margin_start=12, margin_end=12,
                    margin_top=12, margin_bottom=12)
        self.attente_vide = Adw.StatusPage(icon_name="view-list-bullet-symbolic", title=_("Liste vide"),
                                           description=_("Ajoutez des applications avec le bouton + de leur "
                                                         "carte : elles s'installeront toutes ensemble, d'un "
                                                         "seul clic."), vexpand=True)
        self.attente_vide.add_css_class("compact")
        b.append(self.attente_vide)
        self.liste_attente = Gtk.ListBox(selection_mode=Gtk.SelectionMode.NONE)
        self.liste_attente.add_css_class("boxed-list")
        sw = Gtk.ScrolledWindow(hscrollbar_policy=Gtk.PolicyType.NEVER, vexpand=True)
        sw.set_child(self.liste_attente)
        self.attente_defile = sw
        b.append(sw)
        self.bouton_tout = Gtk.Button(label=_("Tout installer"))
        self.bouton_tout.add_css_class("suggested-action")
        self.bouton_tout.add_css_class("pill")
        self.bouton_tout.connect("clicked", lambda *_: self.installer(list(self.attente)))
        b.append(self.bouton_tout)
        self.bouton_vider = Gtk.Button(label=_("Vider la liste"))
        self.bouton_vider.add_css_class("flat")
        self.bouton_vider.connect("clicked", lambda *_: self.vider_attente())
        b.append(self.bouton_vider)
        tv.set_content(b)
        return tv

    def basculer_attente(self, i):
        if i in self.attente:
            self.attente.remove(i)
        else:
            self.attente.append(i)
            nom = self.par_id[i]["nom"] if i in self.par_id else i
            self.toast(_("{nom} ajoutée à la liste d'attente").format(nom=nom))
        self.sauver_attente()
        self.rafraichir_boutons()

    def vider_attente(self):
        self.attente.clear()
        self.sauver_attente()
        self.rafraichir_boutons()

    def sauver_attente(self):
        self.attente = [i for i in self.attente if i not in self.installees]
        self.reglages["attente"] = self.attente
        ecrire_reglages(self.reglages)
        self.compteur.set_label(str(len(self.attente)))
        self.compteur.set_visible(bool(self.attente))
        self.liste_attente.remove_all()
        for i in self.attente:
            app = self.par_id.get(i, {"id": i, "nom": i, "resume": "", "icone": None})
            row = Adw.ActionRow(title=GLib.markup_escape_text(app["nom"]),
                                subtitle=GLib.markup_escape_text(app["resume"]), subtitle_lines=1)
            row.add_prefix(self.icone(app, 32))
            rm = Gtk.Button(icon_name="list-remove-symbolic", valign=Gtk.Align.CENTER,
                            tooltip_text=_("Retirer de la liste"))
            rm.add_css_class("flat")
            rm.connect("clicked", lambda _b, i=i: self.basculer_attente(i))
            rm.set_sensitive(not self.occupe)
            row.add_suffix(rm)
            self.liste_attente.append(row)
        n = len(self.attente)
        self.attente_vide.set_visible(n == 0)
        self.attente_defile.set_visible(n > 0)
        self.bouton_tout.set_visible(n > 0)
        self.bouton_vider.set_visible(n > 0)
        self.bouton_tout.set_label(ngettext("Installer l'application", "Installer les {n} applications", n).format(n=n))
        self.bouton_tout.set_sensitive(not self.occupe)
        self.bouton_vider.set_sensitive(not self.occupe)

    def rafraichir_boutons(self):
        self.cartes = [c for c in self.cartes if c.get_root() is not None]
        for c in self.cartes:
            c.actualiser()
        for f in list(self.fiches_boutons):
            f()

    # ---------- installées, mises à jour ----------

    def page_installees(self):
        b = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        self.groupe_installees = Adw.PreferencesGroup(title=_("Applications installées"))
        b.append(self.groupe_installees)
        self.groupe_menage = Adw.PreferencesGroup(title=_("Ménage"), visible=False)
        self.ligne_menage = Adw.ActionRow(title=_("Composants qui ne servent plus"),
                                          subtitle=_("Bibliothèques communes laissées par des applications "
                                                     "retirées"))
        bm = Gtk.Button(label=_("Retirer"), valign=Gtk.Align.CENTER)
        bm.connect("clicked", lambda *_: self.menage())
        self.ligne_menage.add_suffix(bm)
        self.groupe_menage.add(self.ligne_menage)
        b.append(self.groupe_menage)
        self.groupe_orphelins = Adw.PreferencesGroup(
            title=_("Données d'applications retirées"),
            description=_("Réglages et fichiers laissés dans votre dossier personnel par des applications qui ne "
                          "sont plus installées"), visible=False)
        self.lignes_orphelins = []
        b.append(self.groupe_orphelins)
        return self.page_defilante(b, 900)

    def remplir_orphelins(self):
        def travail():
            racine = os.path.expanduser("~/.var/app")
            try:
                noms = sorted(os.listdir(racine))
            except OSError:
                noms = []
            presentes = set(self.installees) | Moteur.installees_utilisateur()
            res = [(n, taille_dossier(os.path.join(racine, n))) for n in noms
                   if n not in presentes and os.path.isdir(os.path.join(racine, n))]
            GLib.idle_add(afficher, res)

        def afficher(res):
            self.vider_groupe(self.groupe_orphelins, self.lignes_orphelins)
            for n, t in res:
                row = Adw.ActionRow(title=GLib.markup_escape_text((self.par_id.get(n) or {}).get("nom") or n),
                                    subtitle=f"~/.var/app/{n} · {taille_lisible(t)}")
                b = Gtk.Button(label=_("Effacer"), valign=Gtk.Align.CENTER)
                b.add_css_class("destructive-action")
                b.connect("clicked", lambda _b, n=n: self.confirmer_effacement(n))
                row.add_suffix(b)
                self.groupe_orphelins.add(row)
                self.lignes_orphelins.append(row)
            self.groupe_orphelins.set_visible(bool(res))
            return False
        threading.Thread(target=travail, daemon=True).start()

    def confirmer_effacement(self, n):
        d = Adw.AlertDialog(heading=_("Effacer ces données ?"),
                            body=_("Réglages, comptes enregistrés et fichiers de {nom} seront supprimés "
                                   "définitivement.").format(nom=(self.par_id.get(n) or {}).get("nom") or n))
        d.add_response("non", _("Annuler"))
        d.add_response("oui", _("Effacer"))
        d.set_response_appearance("oui", Adw.ResponseAppearance.DESTRUCTIVE)
        d.set_default_response("non")
        d.connect("response", lambda _d, r: r == "oui" and (self.effacer_donnees(n),
                                                            self.toast(_("Données effacées"))))
        d.present(self)

    def page_maj(self):
        b = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=14)
        self.maj_vide = Adw.StatusPage(icon_name="object-select-symbolic", title=_("Tout est à jour"),
                                       description=_("Les applications Flatpak sont aussi mises à jour "
                                                     "par KemmOS-Update."))
        b.append(self.maj_vide)
        self.groupe_maj = Adw.PreferencesGroup(title=_("Mises à jour disponibles"), visible=False)
        self.bouton_maj = Gtk.Button(label=_("Tout mettre à jour"), valign=Gtk.Align.CENTER)
        self.bouton_maj.add_css_class("suggested-action")
        self.bouton_maj.connect("clicked", lambda *_: self.mettre_a_jour())
        self.groupe_maj.set_header_suffix(self.bouton_maj)
        b.append(self.groupe_maj)
        return self.page_defilante(b, 900)

    def vider_groupe(self, groupe, lignes):
        for r in lignes:
            groupe.remove(r)
        lignes.clear()

    def remplir_installees(self):
        self.vider_groupe(self.groupe_installees, self.lignes_installees)
        for i, ref in sorted(self.installees.items(),
                             key=lambda kv: (self.par_id.get(kv[0], {}).get("nom")
                                             or kv[1].get_appdata_name() or kv[0]).casefold()):
            app = self.par_id.get(i, {"id": i, "nom": ref.get_appdata_name() or i,
                                      "resume": ref.get_appdata_summary() or "", "icone": None})
            row = Adw.ActionRow(title=GLib.markup_escape_text(app["nom"]),
                                subtitle=GLib.markup_escape_text(
                                    f"{app['resume']} · {taille_lisible(ref.get_installed_size())}"
                                    if app["resume"] else taille_lisible(ref.get_installed_size())),
                                subtitle_lines=1)
            row.add_prefix(self.icone(app, 40))
            o = Gtk.Button(label=_("Ouvrir"), valign=Gtk.Align.CENTER)
            o.connect("clicked", lambda _b, i=i: self.ouvrir(i))
            r = Gtk.Button(icon_name="user-trash-symbolic", valign=Gtk.Align.CENTER, tooltip_text=_("Retirer"))
            r.add_css_class("flat")
            r.set_sensitive(not self.occupe)
            r.connect("clicked", lambda _b, i=i: self.demander_retrait(i))
            row.add_suffix(o)
            row.add_suffix(r)
            if i in self.par_id:
                row.set_activatable(True)
                row.connect("activated", lambda _r, a=self.par_id[i]: self.ouvrir_fiche(a))
            self.groupe_installees.add(row)
            self.lignes_installees.append(row)
        n = len(self.installees)
        self.groupe_installees.set_description(ngettext("{n} application Flatpak sur cet ordinateur",
                                                        "{n} applications Flatpak sur cet ordinateur", n).format(n=n))
        self.remplir_orphelins()
        self.groupe_menage.set_visible(bool(self.inutiles))
        if self.inutiles:
            n = len(self.inutiles)
            self.ligne_menage.set_subtitle(
                ngettext("{n} élément, {taille} : bibliothèques laissées par des applications retirées",
                         "{n} éléments, {taille} : bibliothèques laissées par des applications retirées", n)
                .format(n=n, taille=taille_lisible(sum(r.get_installed_size() for r in self.inutiles))))

    def remplir_maj(self):
        self.vider_groupe(self.groupe_maj, self.lignes_maj)
        for ref in self.maj:
            i = ref.get_name()
            app = self.par_id.get(i)
            nom = app["nom"] if app else (ref.get_appdata_name() or i)
            if ref.get_kind() != Flatpak.RefKind.APP:
                nom = _("{nom} (composant commun)").format(nom=nom)
            row = Adw.ActionRow(title=GLib.markup_escape_text(nom),
                                subtitle=GLib.markup_escape_text(ref.get_appdata_version() or ref.get_branch()))
            row.add_prefix(self.icone(app or {"id": i, "icone": None}, 32))
            self.groupe_maj.add(row)
            self.lignes_maj.append(row)
        n = len(self.maj)
        self.groupe_maj.set_visible(n > 0)
        self.maj_vide.set_visible(n == 0)
        self.bouton_maj.set_sensitive(not self.occupe)
        self.page_pile_maj.set_badge_number(n)
        self.page_pile_maj.set_needs_attention(n > 0)

    def sur_onglet(self):
        if self.pile.get_visible_child_name() in ("installees", "maj") and self.moteur and not self.occupe:
            self.relire_etat()

    # ---------- chargement ----------

    def chargement_initial(self, forcer=False):
        self.sauver_attente()
        self.chargement.set_visible(True)
        if forcer:
            self.chargement_texte.set_label(_("Téléchargement du catalogue Flathub…"))

        def travail():
            try:
                if self.moteur is None:
                    self.moteur = Moteur()
                if forcer or not os.path.exists(os.path.join(APPSTREAM, "appstream.xml.gz")):
                    GLib.idle_add(self.chargement_texte.set_label, _("Téléchargement du catalogue Flathub…"))
                self.moteur.rafraichir_catalogue(forcer)
                apps = catalogue.charger(APPSTREAM, os.path.join(CACHE, f"catalogue-{LANGUE}.json"),
                                         LANGUES_APPSTREAM)
                try:   # cache sans langue des versions 0.1 et 0.2
                    os.remove(os.path.join(CACHE, "catalogue.json"))
                except OSError:
                    pass
                inst = self.moteur.installees()
                maj = self.moteur.a_mettre_a_jour()
                inutiles = self.moteur.inutilises()
            except (GLib.Error, OSError) as e:
                GLib.idle_add(self.echec_chargement, message_erreur(e))
                return
            GLib.idle_add(self.catalogue_pret, apps, inst, maj, inutiles)
            pop = catalogue.popularite(os.path.join(CACHE, "popularite.json"))
            if pop:
                GLib.idle_add(self.popularite_prete, pop)
        threading.Thread(target=travail, daemon=True).start()

    def echec_chargement(self, msg):
        self.chargement.set_visible(False)
        if "appstream" in msg.lower():
            # catalogue à moitié installé (ordinateur éteint pendant son installation) : réparé au démarrage
            msg += "\n\n" + _("Redémarrez l'ordinateur : KemmOS répare le catalogue au démarrage, "
                                "puis rouvrez KemmOS-Apps.")
        self.decouvrir.append(Adw.StatusPage(icon_name="network-offline-symbolic",
                                             title=_("Catalogue indisponible"),
                                             description=GLib.markup_escape_text(msg)))

    def catalogue_pret(self, apps, inst, maj, inutiles):
        self.apps, self.par_id = apps, {a["id"]: a for a in apps}
        self.systeme = catalogue.applis_systeme()
        self.installees, self.maj, self.inutiles = inst, maj, inutiles
        self.chargement.set_visible(False)
        self.sauver_attente()
        self.remplir_accueil()
        self.remplir_installees()
        self.remplir_maj()
        if self.fiche_demandee:
            self.montrer_fiche(self.fiche_demandee)

    def montrer_fiche(self, ident):
        """Ouvre la fiche d'une application du catalogue (Centre, assistant Windows, fichier .flatpakref)."""
        if not self.apps:
            self.fiche_demandee = ident   # catalogue pas encore chargé : ouverte par catalogue_pret
            return
        self.fiche_demandee = None
        app = self.par_id.get(ident) or self.par_id.get(ident.removesuffix(".desktop"))
        if app:
            self.ouvrir_fiche(app)
        else:
            self.toast(_("« {id} » n'est pas dans le catalogue Flathub").format(id=ident))

    def popularite_prete(self, pop):
        self.pop = pop
        if self.apps:
            self.remplir_accueil()

    def relire_etat(self, ensuite=None):
        def travail():
            try:
                inst = self.moteur.installees()
                maj = self.moteur.a_mettre_a_jour()
                inutiles = self.moteur.inutilises()
            except GLib.Error:
                return
            GLib.idle_add(fin, inst, maj, inutiles)

        def fin(inst, maj, inutiles):
            self.installees, self.maj, self.inutiles = inst, maj, inutiles
            self.systeme = catalogue.applis_systeme()
            self.sauver_attente()
            self.remplir_installees()
            self.remplir_maj()
            self.rafraichir_boutons()
            if ensuite:
                ensuite()
        threading.Thread(target=travail, daemon=True).start()

    # ---------- actions ----------

    def ouvrir(self, i):
        info = None
        try:
            info = DesktopAppInfo.new(i + ".desktop")
        except TypeError:
            pass
        try:
            if info is not None:
                info.launch([], None)
            else:
                subprocess.Popen(["flatpak", "run", i], start_new_session=True)
        except (GLib.Error, OSError) as e:
            self.alerte(_("Impossible d'ouvrir l'application"), message_erreur(e))

    def ouvrir_lanceur(self, lanceur):
        """Application installée par le système : lanceur .desktop de /usr/share/applications."""
        try:
            DesktopAppInfo.new(lanceur).launch([], None)
        except (GLib.Error, TypeError, AttributeError) as e:   # lanceur disparu : new() renvoie None
            self.alerte(_("Impossible d'ouvrir l'application"), message_erreur(e))

    def installer(self, ids):
        ids = [i for i in ids if i in self.par_id and i not in self.installees]
        if not ids or self.occupe:
            return
        ops = [("install", self.par_id[i]["ref"], self.par_id[i]["nom"]) for i in ids]
        noms = ", ".join(self.par_id[i]["nom"] for i in ids)
        self.lancer(ops, _("Installé : {noms}").format(noms=noms) if len(ids) == 1 else
                    ngettext("{n} application installée", "{n} applications installées", len(ids)).format(n=len(ids)),
                    retirer_attente=ids)

    def demander_retrait(self, i):
        ref = self.installees.get(i)
        if ref is None or self.occupe:
            return
        nom = self.par_id[i]["nom"] if i in self.par_id else (ref.get_appdata_name() or i)
        d = Adw.AlertDialog(heading=_("Retirer {nom} ?").format(nom=nom),
                            body=_("L'application est retirée de l'ordinateur. Vos documents ne sont pas touchés."))
        effacer = None
        if os.path.isdir(donnees_app(i)):
            effacer = Gtk.CheckButton(label=_("Effacer aussi ses réglages et ses données ({taille})").format(
                taille=taille_lisible(taille_dossier(donnees_app(i)))))
            d.set_extra_child(effacer)
        d.add_response("non", _("Annuler"))
        d.add_response("oui", _("Retirer"))
        d.set_response_appearance("oui", Adw.ResponseAppearance.DESTRUCTIVE)
        d.set_default_response("non")
        d.connect("response", lambda _d, r: r == "oui" and self.lancer(
            [("uninstall", ref.format_ref(), nom)], _("{nom} retirée").format(nom=nom),
            apres_ok=(lambda: self.effacer_donnees(i)) if effacer is not None and effacer.get_active() else None))
        d.present(self)

    def effacer_donnees(self, i):
        """Réglages et données d'une application retirée (~/.var/app/<id>), et ses autorisations modifiées."""
        if i in self.installees or i in Moteur.installees_utilisateur():
            return
        shutil.rmtree(donnees_app(i), ignore_errors=True)
        try:
            os.remove(os.path.join(autorisations.OVERRIDES, i))
        except OSError:
            pass
        if hasattr(self, "groupe_orphelins"):
            self.remplir_orphelins()

    def mettre_a_jour(self):
        if not self.maj or self.occupe:
            return
        ops = [("update", r.format_ref(), (self.par_id.get(r.get_name()) or {}).get("nom") or r.get_name())
               for r in self.maj]
        self.lancer(ops, _("Mises à jour installées"))

    def menage(self):
        if not self.inutiles or self.occupe:
            return
        ops = [("uninstall", r.format_ref(), r.get_name()) for r in self.inutiles]
        self.lancer(ops, _("Composants inutilisés retirés"))

    def lancer(self, ops, message_ok, retirer_attente=(), apres_ok=None):
        self.occupe = True
        self.annulation = Gio.Cancellable()
        self.barre_texte.set_label(_("Préparation…"))
        self.barre_progres.set_fraction(0)
        self.barre.set_reveal_child(True)
        self.bouton_annuler.set_sensitive(True)
        self.sauver_attente()
        self.rafraichir_boutons()
        self.remplir_maj()

        def progres(texte, fraction):
            GLib.idle_add(lambda: (self.barre_texte.set_label(texte),
                                   self.barre_progres.set_fraction(min(max(fraction, 0), 1))) and False)

        def travail():
            try:
                erreurs = self.moteur.executer(ops, progres, self.annulation)
                err = None
            except GLib.Error as e:
                erreurs, err = [], e
            GLib.idle_add(fin, erreurs, err)

        def fin(erreurs, err):
            self.occupe = False
            self.barre.set_reveal_child(False)
            annule = self.annulation.is_cancelled()
            self.annulation = None

            def apres():
                if annule:
                    self.toast(_("Opération annulée"))
                elif err is not None:
                    self.alerte(_("L'opération n'a pas abouti"), message_erreur(err))
                elif erreurs:
                    self.alerte(_("Certaines applications n'ont pas pu être traitées"), "\n".join(erreurs))
                else:
                    self.toast(message_ok)
                    self.envoyer_notification(message_ok)
                    if apres_ok:
                        apres_ok()
            self.relire_etat(apres)
        threading.Thread(target=travail, daemon=True).start()

    def envoyer_notification(self, texte):
        """Notification du bureau si la fenêtre n'est pas au premier plan (installation longue)."""
        if self.is_active():
            return
        n = Gio.Notification.new("KemmOS-Apps")
        n.set_body(texte)
        self.get_application().send_notification("fin", n)

    def a_propos(self):
        traducteurs = _("translator-credits")
        d = Adw.AboutDialog(application_name="KemmOS-Apps", application_icon=APP_ID, version=VERSION,
                            developer_name="Nawre", website="https://nawre-tech.log.bzh/kemmos/",
                            license_type=Gtk.License.GPL_3_0,
                            comments=_("Logithèque Flathub de KemmOS : applications vérifiées, catégories, liste "
                                       "d'attente pour en installer plusieurs d'un coup."))
        if traducteurs != "translator-credits":
            d.set_translator_credits(traducteurs)
        d.present(self)


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

    def do_startup(self):
        Adw.Application.do_startup(self)
        css = Gtk.CssProvider()
        css.load_from_string(CSS)
        Gtk.StyleContext.add_provider_for_display(Gdk.Display.get_default(), css,
                                                  Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)

    def do_activate(self):
        fen = self.get_active_window() or Fenetre(self)
        fen.present()
        return fen

    def do_command_line(self, ligne):
        # kemmos-apps [--details=ID | appstream://ID | fichier.flatpakref]
        # (KemmOS Centre, assistant « Je viens de Windows », bouton Installer du site flathub.org)
        ident = None
        for a in ligne.get_arguments()[1:]:
            if a.startswith("--details="):
                ident = a.split("=", 1)[1]
            elif a.startswith("appstream:"):
                ident = a.split(":", 1)[1].lstrip("/")
            elif a.endswith(".flatpakref") or a.startswith("file:"):
                ident = id_flatpakref(ligne.create_file_for_arg(a)) or ""
        fen = self.do_activate()
        if ident:
            fen.montrer_fiche(ident)
        elif ident == "":
            fen.toast(_("Fichier .flatpakref illisible"))
        return 0


def id_flatpakref(fichier):
    """Identifiant de l'application d'un fichier .flatpakref (clé Name= du groupe [Flatpak Ref])."""
    try:
        cle = GLib.KeyFile()
        cle.load_from_bytes(GLib.Bytes.new(fichier.load_contents(None)[1]), GLib.KeyFileFlags.NONE)
        return cle.get_string("Flatpak Ref", "Name")
    except GLib.Error:
        return None


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