#!/usr/bin/python3
# Centre KemmOS — logiciels optionnels après coup (build 79 ; 1.3.0 : choix logiciel par logiciel, retrait).
# Lancé par pkexec (action org.kemmos.centre.groupes) :
#   groupes install <groupe>                       tout le groupe (comme la case cochée dans l'installateur)
#   groupes appliquer <groupe> +<élément>… -<élément>…   installe les « + », retire les « - »
#   groupes simuler <groupe> -<élément>…           liste de ce que zypper retirerait (rien n'est modifié)
# Mêmes groupes que l'installateur (/usr/share/kemmos/groupes.yml), même pre-install/post-install (seulement
# s'il y a quelque chose à installer), entrées « flatpak:<id> » depuis Flathub. Les éléments demandés doivent
# appartenir au groupe ; ceux du socle de KemmOS (/usr/share/kemmos/socle-groupes.txt) ne sont jamais retirés.
# Sortie ligne par ligne (lue en direct par le Centre) ; code 0 = tout fait, 1 = échecs, 2 = usage.
import os
import re
import shlex
import subprocess
import sys

import yaml

GROUPES = "/usr/share/kemmos/groupes.yml"
SOCLE = "/usr/share/kemmos/socle-groupes.txt"
# Comme pendant l'installation (config.sh) : sans verrous, les « recommends » de samba (Power users)
# ramènent 44 paquets YaST. Posés seulement pour la durée de l'opération, et seulement si YaST est absent
# (s'il a été installé volontairement, on n'y touche pas).
VERROUS = ["yast2*", "libyui*", "autoyast2*"]
FP = "flatpak:"
# zypper occupé (vérification des mises à jour, GNOME Logiciels…) : attendre qu'il se libère plutôt qu'échouer
# aussitôt — vu en test : simulation en échec juste après l'ouverture de session (kemmos-update en cours)
os.environ["ZYPP_LOCK_TIMEOUT"] = "120"


def dire(texte):
    print(texte, flush=True)


def lancer(cmd):
    dire("$ " + " ".join(shlex.quote(c) for c in cmd))
    try:
        return subprocess.run(cmd, stdout=sys.stdout, stderr=subprocess.STDOUT).returncode
    except OSError as e:
        dire(f"✗ {e}")
        return 127


def zypper_ok(code):
    # codes >= 100 : succès avec information (redémarrage conseillé…)
    return code == 0 or code >= 100


def trouver(nom):
    with open(GROUPES) as f:
        pile = list(yaml.safe_load(f) or [])
    while pile:
        g = pile.pop()
        if g.get("name") == nom:
            return g
        pile.extend(g.get("subgroups") or [])
    return None


def socle():
    try:
        with open(SOCLE) as f:
            return set(f.read().split())
    except OSError:
        return set()


def verrous_a_poser():
    if subprocess.run(["rpm", "-q", "--quiet", "yast2"]).returncode == 0:
        return []
    sortie = subprocess.run(["zypper", "--non-interactive", "locks"], capture_output=True, text=True).stdout
    return [v for v in VERROUS if v not in sortie]


def paquets_reels(noms):
    """Noms des paquets installés qui fournissent @noms (python3-pip → python313-pip…) : zypper remove
    attend des noms de paquets."""
    res = []
    for n in noms:
        r = subprocess.run(["rpm", "-q", "--whatprovides", "--qf", "%{NAME}\n", n],
                           capture_output=True, text=True)
        if r.returncode == 0:
            res += [p for p in r.stdout.split() if p not in res]
    return res


def installer(groupe, elems, echecs):
    paquets = [p for p in elems if not p.startswith(FP)]
    flatpaks = [p[len(FP):] for p in elems if p.startswith(FP)]
    dire(f"==> Installation : {len(paquets)} paquet(s), {len(flatpaks)} application(s) Flatpak")
    if groupe.get("pre-install"):
        dire("==> Préparation")
        if lancer(shlex.split(groupe["pre-install"])) != 0:
            dire("✗ Préparation en échec")
            echecs += elems
            return
    verrous = verrous_a_poser()
    if verrous:
        subprocess.run(["zypper", "--non-interactive", "addlock", *verrous], capture_output=True)
    try:
        if paquets:
            dire("==> Installation des paquets")
            lancer(["zypper", "--non-interactive", "--gpg-auto-import-keys", "refresh"])
            # busybox-ed (fournit /usr/bin/ed mais pas « ed », tiré par quilt sur les PC d'avant le build 86)
            # bloque spyder : remplacé par GNU ed (dans l'image depuis le build 86), seul changement que
            # --force-resolution peut décider ici (zypper -n refuserait sinon toute la liste)
            if "spyder" in paquets and subprocess.run(["rpm", "-q", "--quiet", "busybox-ed"]).returncode == 0:
                lancer(["zypper", "--non-interactive", "install", "--force-resolution", "ed"])
            base = ["zypper", "--non-interactive", "install", "--auto-agree-with-licenses"]
            if not zypper_ok(lancer(base + paquets)):
                # une seule transaction en échec : paquet par paquet, pour installer tout ce qui peut l'être
                dire("==> Nouvel essai paquet par paquet")
                for p in paquets:
                    if not zypper_ok(lancer(base + [p])):
                        echecs.append(p)
    finally:
        if verrous:
            subprocess.run(["zypper", "--non-interactive", "removelock", *verrous], capture_output=True)
    if flatpaks:
        dire("==> Applications Flatpak (Flathub)")
        for a in flatpaks:
            if lancer(["flatpak", "install", "--system", "--noninteractive", "-y", "flathub", a]) != 0:
                echecs.append(FP + a)
    if groupe.get("post-install"):
        dire("==> Finalisation")
        if lancer(shlex.split(groupe["post-install"])) != 0:
            echecs.append("post-install")


def retirer(elems, echecs):
    paquets = paquets_reels([p for p in elems if not p.startswith(FP)])
    flatpaks = [p[len(FP):] for p in elems if p.startswith(FP)]
    dire(f"==> Retrait : {len(paquets)} paquet(s), {len(flatpaks)} application(s) Flatpak")
    if paquets and not zypper_ok(lancer(["zypper", "--non-interactive", "remove", *paquets])):
        echecs += paquets
    for a in flatpaks:
        if lancer(["flatpak", "uninstall", "--system", "--noninteractive", "-y", a]) != 0:
            echecs.append(FP + a)


def simuler(elems):
    """Paquets que zypper retirerait réellement (dépendances comprises) : une ligne « RETIRE <nom> » chacun."""
    paquets = paquets_reels([p for p in elems if not p.startswith(FP)])
    if paquets:
        r = subprocess.run(["zypper", "--non-interactive", "remove", "--dry-run", *paquets],
                           capture_output=True, text=True, env=dict(os.environ, LANG="C", LC_ALL="C"))
        liste, dedans = [], False
        for ligne in r.stdout.splitlines():
            if re.match(r"^The following \d+ packages? (is|are) going to be REMOVED:", ligne):
                dedans = True
            elif dedans and ligne.startswith("  "):
                liste += ligne.split()
            elif dedans:
                dedans = False
        if r.returncode != 0 and not liste:
            dire("✗ " + (r.stdout.strip().splitlines() or ["zypper en échec"])[-1])
            return 1
        for p in liste:
            dire("RETIRE " + p)
    for a in elems:
        if a.startswith(FP):
            dire("RETIRE " + a)
    return 0


def main():
    a = sys.argv[1:]
    if len(a) < 2 or a[0] not in ("install", "appliquer", "simuler") or (a[0] == "install" and len(a) != 2):
        dire("usage : groupes install <groupe> | appliquer <groupe> +élément… -élément… | "
             "simuler <groupe> -élément…")
        return 2
    groupe = trouver(a[1])
    if groupe is None:
        dire(f"Groupe inconnu : {a[1]}")
        return 2
    contenu = [str(p) for p in groupe.get("packages") or []]
    if a[0] == "install":
        plus, moins = contenu, []
    else:
        plus = [e[1:] for e in a[2:] if e.startswith("+")]
        moins = [e[1:] for e in a[2:] if e.startswith("-")]
        intrus = [e for e in a[2:] if e[:1] not in "+-" or e[1:] not in contenu]
        if intrus:
            dire("Éléments hors du groupe : " + " ".join(intrus))
            return 2
        proteges = [e for e in moins if e in socle()]
        if proteges:
            dire("Fait partie de KemmOS, non retiré : " + " ".join(proteges))
            moins = [e for e in moins if e not in proteges]
    if a[0] == "simuler":
        return simuler(moins)

    echecs = []
    dire(f"==> Groupe « {groupe['name']} »")
    if moins:
        retirer(moins, echecs)
    if plus:
        installer(groupe, plus, echecs)
    if echecs:
        dire("✗ En échec : " + ", ".join(echecs))
        return 1
    dire("✓ Terminé")
    return 0


if __name__ == "__main__":
    sys.exit(main())
