#!/usr/bin/bash
#
# geeko-update — Outil de maintenance système pour GeekOS
# Version 1.4.1 (dernière version : GeekOS est devenu KemmOS, voir migrate_kemmos)
#
# Usage : sudo geeko-update [options]   (voir --help)

ORIG_ARGS=("$@")
LOGFILE="/var/log/geeko-update.log"
STATUS_DIR="/var/lib/geeko-update"
STATUS_FILE="$STATUS_DIR/status.json"
MODE="apply"
DO_LOG=true
ERRORS=0
WARNINGS=0

RUN_SYSTEM=false
RUN_FIRMWARE=false
RUN_FLATPAK=false
RUN_CACHE=false
RUN_ORPHANS=false
RUN_SERVICES=false
RUN_REBOOT=false
RUN_SNAPSHOTS=false
ANY_STEP_SELECTED=false

# --- Couleurs (désactivées si la sortie n'est pas un vrai terminal,
#     comme lorsque le script est appelé par pkexec ou par systemd) ---
if [ -t 1 ]; then
    RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[0;33m'; BLUE='\033[0;34m'; NC='\033[0m'
else
    RED=''; GREEN=''; YELLOW=''; BLUE=''; NC=''
fi

step()  { echo -e "\n${BLUE}==> $1${NC}"; }
ok()    { echo -e "${GREEN}✓ $1${NC}"; }
warn()  { echo -e "${YELLOW}⚠ $1${NC}"; WARNINGS=$((WARNINGS+1)); }
error() { echo -e "${RED}✗ $1${NC}"; ERRORS=$((ERRORS+1)); }

# Programme qui détient le verrou zypp (/run/zypp.pid), vide si aucun
zypp_holder() {
    local pid
    pid=$(cat /run/zypp.pid 2>/dev/null)
    if [ -n "$pid" ] && [ "$pid" != "$$" ] && [ -d "/proc/$pid" ]; then
        echo "$(cat "/proc/$pid/comm" 2>/dev/null) (PID $pid)"
    fi
}

# zypper s'est arrêté (code 7) car un autre programme utilise la gestion des paquets
zypp_locked_msg() {
    local who
    who=$(zypp_holder)
    error "Gestion des paquets occupée par un autre programme${who:+ : $who}"
    echo "   Souvent la Logithèque (GNOME Software / PackageKit) qui vérifie les mises à jour."
    echo "   Attendez qu'il ait fini puis relancez Geeko-Update."
}

# Extrait le(s) problème(s) de dépendances de la sortie de zypper (entrée standard)
problem_text() {
    sed -n '/^Probl[eè]m/,/^\(Choose from above\|Choisissez parmi\)/p' | grep -vE '^(Choose from above|Choisissez parmi)' | head -25
}

# zypper s'est arrêté (code 4) sur un conflit entre paquets : il attend un choix
zypp_problem_msg() {
    error "Mise à jour bloquée : zypper demande de choisir entre plusieurs solutions (conflit entre paquets)"
    problem_text < "$1" | sed 's/^/   /'
    echo "   Geeko-Update ne choisit pas à votre place. Pour décider vous-même, dans un terminal :"
    echo "      sudo zypper dup"
    echo "   Souvent, il suffit d'attendre un jour ou deux que les dépôts soient cohérents."
}

# Taille lisible (octets → « 1,2 Go »)
human() { numfmt --to=iec --suffix=o --format='%.1f' "$1" 2>/dev/null | sed 's/\./,/; s/\([KMGT]\)o$/ \1o/' ; }

# Espace libre sur / avant zypper dup : téléchargement + espace supplémentaire annoncés par la dernière
# vérification (status.json) + 3 Go de marge (snapshot btrfs, scripts). Sans cette vérification, un disque
# plein en pleine mise à jour laisse un système à moitié mis à jour (1.4.0).
check_free_space() {
    local avail need
    avail=$(df --output=avail -B1 / 2>/dev/null | tail -n 1 | tr -d ' ')
    [ -n "$avail" ] || return 0
    need=$(python3 -c 'import json,sys
try:
    s=json.load(open(sys.argv[1]))
    print(max(int(s.get("download_size",0)),0)+max(int(s.get("space_needed",0)),0))
except Exception:
    print(0)' "$STATUS_FILE" 2>/dev/null)
    need=$(( ${need:-0} + 3*1024*1024*1024 ))
    if [ "$avail" -lt "$need" ]; then
        error "Espace disque insuffisant : $(human "$avail") libres, $(human "$need") nécessaires (marge de 3 Go comprise)"
        echo "   Libérez de la place (Nettoyer seulement : cache et anciens snapshots), puis relancez."
        return 1
    fi
    return 0
}

# Dernier numéro de snapshot snapper (0 si aucun)
last_snapshot() {
    snapper --no-dbus --csvout list --columns number 2>/dev/null | grep -E '^[0-9]+$' | sort -n | tail -n 1
}

# Premier snapshot « pre » créé après le numéro $1 (par le plugin snapper de zypper)
pre_snapshot_after() {
    snapper --no-dbus --csvout list --columns number,type 2>/dev/null \
        | awk -F, -v n="$1" '$1 ~ /^[0-9]+$/ && $1 > n && $2 == "pre" { print $1; exit }'
}

usage() {
cat <<EOF
Geeko-Update — outil de maintenance système pour GeekOS

Usage : sudo $0 [options]

Options :
  --apply           Applique les mises à jour et le nettoyage (par défaut)
  --check           Mode simulation : affiche ce qui serait fait, sans rien modifier
  --status          Vérification silencieuse : écrit l'état dans $STATUS_FILE
                    (utilisé par le timer systemd et l'icône système)
  --system          N'exécute que la mise à jour système
  --firmware        N'exécute que la mise à jour firmware
  --flatpak         N'exécute que la mise à jour des applications Flatpak (installation système)
  --cache           N'exécute que le nettoyage du cache
  --orphans         N'exécute que la recherche de paquets orphelins
  --services        N'exécute que la vérification des services à redémarrer
  --reboot          N'exécute que la vérification du besoin de redémarrage
  --snapshots       N'exécute que le nettoyage des snapshots Snapper
  --no-log          Désactive l'écriture dans le fichier de log ($LOGFILE)
  -h, --help        Affiche cette aide

Sans option de sélection d'étape, toutes les étapes sont exécutées.
EOF
exit 0
}

# Motifs d'avertissements TPM / chiffrement dans la sortie des mises à jour
TPM_PATTERN='pcrlock|TPM2 policy|TPM Error|PCR [0-9,]+ moved'

# Le disque est-il chiffré avec déverrouillage automatique par la puce TPM ?
has_tpm_fde() {
    grep -qi 'tpm2' /etc/crypttab 2>/dev/null || [ -f /var/lib/systemd/pcrlock.json ]
}

# Une mise à jour firmware touchant le démarrage sécurisé est-elle en attente ?
# (lit la sortie JSON de fwupdmgr get-updates sur l'entrée standard)
FW_SENSITIVE_PY='
import sys, json, re
try:
    devices = json.load(sys.stdin).get("Devices", [])
except Exception:
    devices = []
names = [d.get("Name", "?") for d in devices
         if re.search(r"UEFI|dbx|KEK|System Firmware|BIOS|Secure", d.get("Name", ""), re.I)]
print(", ".join(names))
'

# --- Écrit le fichier d'état (nombre de mises à jour, cache, snapshots...) ---
# $1 = true pour rafraîchir aussi les métadonnées firmware
write_status() {
    local refresh_fw="$1"
    mkdir -p "$STATUS_DIR"
    chmod 755 "$STATUS_DIR"
    local tmp
    tmp=$(mktemp -d)

    # Paquets : simulation de zypper dup en sortie XML (indépendante de la langue)
    zypper --non-interactive --quiet refresh >/dev/null 2>&1
    # --auto-agree-with-licenses : sans lui, une mise à jour du pilote NVIDIA (licence à accepter) fait
    # échouer même la simulation (code 4) → « Impossible de vérifier » (constaté sur PC RTX, GeekOS 73)
    zypper --non-interactive --xmlout dup --dry-run --auto-agree-with-licenses > "$tmp/zypper.xml" 2>/dev/null
    local zrc=$?
    if [ "$zrc" -eq 7 ]; then
        # zypper est déjà utilisé par un autre programme : on garde l'état précédent
        rm -rf "$tmp"
        return 0
    fi

    # Firmware : métadonnées LVFS rafraîchies au plus une fois par jour
    # (le timer tourne toutes les heures ; une fois par jour suffit et ménage le serveur LVFS)
    if command -v fwupdmgr &> /dev/null; then
        local fw_stamp="$STATUS_DIR/fw-refresh"
        if [ "$refresh_fw" = true ] && \
           { [ ! -f "$fw_stamp" ] || [ -n "$(find "$fw_stamp" -mmin +1440 2>/dev/null)" ]; }; then
            fwupdmgr refresh --force >/dev/null 2>&1 && touch "$fw_stamp"
        fi
        fwupdmgr get-updates --json > "$tmp/fw.json" 2>/dev/null
    fi

    # Applications Flatpak (installation système) : -1 = impossible de savoir
    local flatpaks=0
    if command -v flatpak &> /dev/null; then
        if flatpak remote-ls --system --updates --columns=application > "$tmp/flatpak.txt" 2>/dev/null; then
            flatpaks=$(grep -c . "$tmp/flatpak.txt")
        else
            flatpaks=-1
        fi
    fi

    # Infos de nettoyage
    local cache snaps orphans reboot
    cache=$(du -sh /var/cache/zypp 2>/dev/null | cut -f1)
    snaps=0
    command -v snapper &> /dev/null && snaps=$(snapper list 2>/dev/null | grep -c '^[0-9]')
    orphans=$(zypper packages --orphaned 2>/dev/null | grep -c '^i')
    if zypper needs-rebooting >/dev/null 2>&1; then reboot=false; else reboot=true; fi

    local tpm_fde=false
    has_tpm_fde && tpm_fde=true

    # Code 4 : en général un conflit entre paquets pour lequel zypper attend un choix (impossible en
    # --non-interactive). Le texte du problème est gardé pour l'icône système.
    : > "$tmp/problem.txt"
    if [ "$zrc" -eq 4 ]; then
        LC_ALL=C zypper --non-interactive dup --dry-run --auto-agree-with-licenses 2>&1 | problem_text > "$tmp/problem.txt"
    fi

    python3 - "$tmp" "$zrc" "${cache:-?}" "$snaps" "$orphans" "$reboot" "$STATUS_FILE" "$tpm_fde" "$flatpaks" <<'PY'
import sys, json, os, time

tmp, zrc, cache, snaps, orphans, reboot, status_file, tpm_fde, flatpaks = sys.argv[1:10]
zrc = int(zrc)
status = {
    "timestamp": int(time.time()),
    "system": -1,          # -1 = impossible de savoir
    "system_error": 0,     # code zypper quand system = -1
    "firmware": 0,
    "flatpak": int(flatpaks),  # -1 = impossible de savoir
    "cache": cache,
    "snapshots": int(snaps),
    "orphans": int(orphans),
    "reboot": reboot == "true",
    "tpm_fde": tpm_fde == "true",      # disque chiffré déverrouillé par TPM
    "firmware_sensitive": [],          # firmwares en attente touchant le démarrage sécurisé
    "tpm_warning": False,              # avertissement TPM lors de la dernière mise à jour
    "system_problem": "",              # conflit de paquets qui bloque la mise à jour (code 4)
    "packages": [],                    # changements prévus : [action, nom, ancienne, nouvelle] (1.4.0)
    "download_size": 0,                # octets à télécharger
    "space_needed": 0,                 # octets supplémentaires après l'opération (peut être < 0)
    "flatpak_apps": [],                # applications Flatpak à mettre à jour
    "free_root": 0,                    # octets libres sur /
}

ACTIONS = {"to-upgrade": "upgrade", "to-install": "install", "to-remove": "remove",
           "to-downgrade": "downgrade", "to-reinstall": "reinstall", "to-change-arch": "upgrade",
           "to-change-vendor": "upgrade"}

def size(v):
    try:
        return int(v)
    except (TypeError, ValueError):
        return 0

# Nombre de paquets concernés par zypper dup
if zrc == 0 or zrc >= 100:
    try:
        import xml.etree.ElementTree as ET
        root = ET.parse(os.path.join(tmp, "zypper.xml")).getroot()
        summary = root.find(".//install-summary")
        status["system"] = 0 if summary is None else len(summary.findall(".//solvable"))
        if summary is not None:
            status["download_size"] = size(summary.get("download-size"))
            status["space_needed"] = size(summary.get("space-usage-diff"))
            for group in summary:
                action = ACTIONS.get(group.tag, group.tag)
                for sv in group.iter("solvable"):
                    if len(status["packages"]) >= 2000:
                        break
                    status["packages"].append([action, sv.get("name", "?"),
                                               sv.get("edition-old", ""), sv.get("edition", "")])
    except Exception:
        pass
if status["system"] < 0:
    status["system_error"] = zrc
    try:
        with open(os.path.join(tmp, "problem.txt")) as f:
            status["system_problem"] = f.read().strip()
    except Exception:
        pass

# Nombre d'appareils ayant une mise à jour firmware, et lesquels touchent le démarrage sécurisé
try:
    import re
    with open(os.path.join(tmp, "fw.json")) as f:
        devices = json.load(f).get("Devices", [])
    status["firmware"] = len(devices)
    status["firmware_sensitive"] = [
        d.get("Name", "?") for d in devices
        if re.search(r"UEFI|dbx|KEK|System Firmware|BIOS|Secure", d.get("Name", ""), re.I)]
except Exception:
    pass

try:
    with open(os.path.join(tmp, "flatpak.txt")) as f:
        status["flatpak_apps"] = [l.strip() for l in f if l.strip()][:200]
except Exception:
    pass
try:
    st = os.statvfs("/")
    status["free_root"] = st.f_bavail * st.f_frsize
except Exception:
    pass

# Avertissement TPM enregistré pendant ce démarrage (effacé au redémarrage suivant)
try:
    with open(os.path.join(os.path.dirname(status_file), "tpm-warning")) as f:
        flag_boot = f.read().strip()
    with open("/proc/sys/kernel/random/boot_id") as f:
        status["tpm_warning"] = f.read().strip() == flag_boot
except Exception:
    pass

# Écriture "atomique" : fichier temporaire puis renommage
tmpfile = status_file + ".tmp"
with open(tmpfile, "w") as f:
    json.dump(status, f)
os.chmod(tmpfile, 0o644)
os.replace(tmpfile, status_file)
PY
    rm -rf "$tmp"
}

# --- Analyse des options ---
while [ $# -gt 0 ]; do
    case "$1" in
        --apply)      MODE="apply" ;;
        --check)      MODE="check" ;;
        --status)     MODE="status" ;;
        --system)     RUN_SYSTEM=true; ANY_STEP_SELECTED=true ;;
        --firmware)   RUN_FIRMWARE=true; ANY_STEP_SELECTED=true ;;
        --flatpak)    RUN_FLATPAK=true; ANY_STEP_SELECTED=true ;;
        --cache)      RUN_CACHE=true; ANY_STEP_SELECTED=true ;;
        --orphans)    RUN_ORPHANS=true; ANY_STEP_SELECTED=true ;;
        --services)   RUN_SERVICES=true; ANY_STEP_SELECTED=true ;;
        --reboot)     RUN_REBOOT=true; ANY_STEP_SELECTED=true ;;
        --snapshots)  RUN_SNAPSHOTS=true; ANY_STEP_SELECTED=true ;;
        --no-log)     DO_LOG=false ;;
        --passage-kemmos) PASSAGE=true ;;   # usage interne (1.4.1), voir migrate_kemmos
        -h|--help)    usage ;;
        *)
            echo -e "${RED}✗ Option inconnue : $1${NC}"
            echo "Utilisez --help pour la liste des options."
            exit 1
            ;;
    esac
    shift
done

if [ "$ANY_STEP_SELECTED" = false ]; then
    RUN_SYSTEM=true; RUN_FIRMWARE=true; RUN_FLATPAK=true; RUN_CACHE=true; RUN_ORPHANS=true
    RUN_SERVICES=true; RUN_REBOOT=true; RUN_SNAPSHOTS=true
fi

# --- Droits root ---
if [ "$EUID" -ne 0 ]; then
    echo -e "${RED}✗ Ce script doit être lancé avec sudo.${NC}"
    echo "Utilisation : sudo $0 [options] (voir --help)"
    exit 1
fi

# --- Passage à KemmOS (1.4.1) ---
# GeekOS a été renommé KemmOS le 6 octobre 2026 : nouveau dépôt OBS home:Nawrekemmos:KemmOS, où les paquets
# kemmos-* remplacent geekos-* et geeko-update (Provides/Obsoletes). Cette version, la dernière de l'ancien
# dépôt, ajoute le nouveau dépôt avec sa clé (fournie par ce paquet, lui-même signé par l'ancien dépôt : la
# chaîne de confiance est conservée), installe les paquets KemmOS (kemmos-release migre ensuite le système),
# retire l'ancien dépôt et passe la main à kemmos-update. Fait aussi par la vérification horaire (--status) :
# la machine bascule seule. En cas d'échec, rien n'est retiré et le passage est retenté à la prochaine exécution.
KEMMOS_DIR=/usr/share/geeko-update/kemmos
migrate_kemmos() {
    local pkgs="" p out
    for p in geekos-release:kemmos-release geekos-centre:kemmos-centre geekos-style:kemmos-style geeko-update:kemmos-update; do
        rpm -q "${p%%:*}" >/dev/null 2>&1 && pkgs="$pkgs ${p#*:}"
    done
    [ -n "$pkgs" ] || return 1
    rpm --import "$KEMMOS_DIR/depot-kemmos.asc" || return 1
    [ -f /etc/zypp/repos.d/kemmos.repo ] || install -m 0644 "$KEMMOS_DIR/kemmos.repo" /etc/zypp/repos.d/kemmos.repo
    export ZYPP_LOCK_TIMEOUT=120
    out=$(zypper -n ref -r kemmos 2>&1 && zypper -n in $pkgs 2>&1) || {
        logger -t geeko-update -- "passage à KemmOS en échec : $(tail -n 5 <<<"$out" | tr '\n' ' ')"
        echo "$out" | tail -n 20 >&2
        return 1
    }
    zypper -n rr geekos >/dev/null 2>&1
    logger -t geeko-update -- "passage à KemmOS fait :$pkgs"
    return 0
}
if [ "$MODE" != "check" ] && rpm -q geeko-update >/dev/null 2>&1 && ! rpm -q kemmos-update >/dev/null 2>&1; then
    # Vérification horaire (geeko-update-check.service) : retirer geeko-update arrête ce service et tout ce
    # qu'il a lancé, zypper compris → transaction lancée dans une unité systemd à part, qui lui survit.
    if [ "$MODE" = "status" ] && [ "${PASSAGE:-false}" != true ]; then
        systemd-run --quiet --collect --unit=geeko-update-passage-kemmos /usr/bin/geeko-update --status --passage-kemmos \
            >/dev/null 2>&1 || :
        exit 0
    fi
    [ "$MODE" = "status" ] || echo -e "${BLUE}==> GeekOS devient KemmOS : passage au nouveau dépôt et aux paquets KemmOS${NC}"
    if migrate_kemmos && [ -x /usr/bin/kemmos-update ]; then
        args=(); for a in "${ORIG_ARGS[@]}"; do [ "$a" = --passage-kemmos ] || args+=("$a"); done
        exec /usr/bin/kemmos-update "${args[@]}"
    fi
fi

# --- Mode status : vérification silencieuse, pas de log, puis on s'arrête ---
if [ "$MODE" = "status" ]; then
    write_status true
    exit 0
fi

# --- Log ---
if [ "$DO_LOG" = true ]; then
    exec > >(tee -a "$LOGFILE") 2>&1
    echo -e "\n### $(date '+%Y-%m-%d %H:%M:%S') — Geeko-Update (mode: $MODE) ###"
fi

RUN_OUT=$(mktemp)

echo -e "${BLUE}=========================================="
echo -e "   Geeko-Update — Maintenance GeekOS (mode : $MODE)"
echo -e "==========================================${NC}"

# --- 1. Système ---
if [ "$RUN_SYSTEM" = true ]; then
    step "Mise à jour du système (zypper dup)"
    # Verrou zypp tenu par un autre programme : zypper attend jusqu'à 2 min avant d'abandonner (code 7)
    export ZYPP_LOCK_TIMEOUT=120
    if [ -n "$(zypp_holder)" ]; then
        echo "Gestion des paquets occupée ($(zypp_holder)) — attente (2 min maximum)…"
    fi
    if [ "$MODE" = "check" ]; then
        zypper --non-interactive dup --dry-run --auto-agree-with-licenses 2>&1 | tee -a "$RUN_OUT"
        zrc=${PIPESTATUS[0]}
        if [ "$zrc" -eq 7 ]; then
            zypp_locked_msg
        elif [ "$zrc" -eq 4 ] && grep -q '^Probl' "$RUN_OUT"; then
            zypp_problem_msg "$RUN_OUT"
        else
            ok "Simulation terminée (rien n'a été modifié)"
        fi
    elif ! check_free_space; then
        :
    else
        snap_before=$(last_snapshot)
        # licences (pilote NVIDIA…) : acceptées lors du choix du groupe à l'installation
        zypper --non-interactive dup --auto-agree-with-licenses 2>&1 | tee -a "$RUN_OUT"
        zrc=${PIPESTATUS[0]}
        # Point de restauration : snapshot « pre » pris par le plugin snapper juste avant les changements
        restore=$(pre_snapshot_after "${snap_before:-0}")
        # codes >= 100 : succès avec information (ex. 102 = redémarrage conseillé, 103 = zypper mis à jour)
        if [ "$zrc" -eq 0 ] || [ "$zrc" -ge 100 ]; then
            ok "Système à jour"
            if [ -n "$restore" ]; then
                ok "Point de restauration : snapshot $restore (état d'avant la mise à jour)"
                echo "   En cas de problème : au démarrage, menu GRUB « Start bootloader from a read-only"
                echo "   snapshot », choisir le n° $restore, puis accepter la restauration proposée."
            fi
        elif [ "$zrc" -eq 7 ]; then
            zypp_locked_msg
        elif [ "$zrc" -eq 4 ] && grep -q '^Probl' "$RUN_OUT"; then
            zypp_problem_msg "$RUN_OUT"
        else
            error "La mise à jour du système a rencontré un problème (zypper, code $zrc)"
        fi
    fi
    unset ZYPP_LOCK_TIMEOUT
fi

# --- 2. Firmware ---
if [ "$RUN_FIRMWARE" = true ]; then
    step "Firmware (fwupd)"
    if command -v fwupdmgr &> /dev/null; then
        fwupdmgr refresh --force
        if [ "$MODE" = "check" ]; then
            fwupdmgr get-updates
            ok "Vérification terminée (rien n'a été appliqué)"
        else
            sensitive=$(fwupdmgr get-updates --json 2>/dev/null | python3 -c "$FW_SENSITIVE_PY")
            if [ -n "$sensitive" ] && has_tpm_fde; then
                warn "Mise à jour firmware sensible ($sensitive) sur un disque chiffré par TPM :"
                echo "   le déverrouillage automatique pourra échouer au prochain redémarrage."
                echo "   Gardez votre clé de récupération à portée de main."
            fi
            fwupdmgr update -y 2>&1 | tee -a "$RUN_OUT"
            ok "Étape firmware terminée"
        fi
    else
        warn "fwupdmgr n'est pas installé — étape ignorée (sudo zypper install fwupd)"
    fi
fi

# --- 2b. Applications Flatpak ---
if [ "$RUN_FLATPAK" = true ]; then
    step "Applications Flatpak"
    if command -v flatpak &> /dev/null; then
        if [ "$MODE" = "check" ]; then
            flatpak remote-ls --system --updates
            ok "Vérification terminée (rien n'a été appliqué)"
        else
            flatpak update --system --noninteractive -y 2>&1 | tee -a "$RUN_OUT"
            if [ "${PIPESTATUS[0]}" -eq 0 ]; then
                ok "Applications Flatpak à jour"
            else
                error "La mise à jour des applications Flatpak a rencontré un problème"
            fi
            # Runtimes devenus inutiles (anciennes versions remplacées par la mise à jour)
            flatpak uninstall --system --unused --noninteractive -y >/dev/null 2>&1
        fi
    else
        ok "Flatpak n'est pas installé — étape ignorée"
    fi
fi

# --- 3. Cache ---
if [ "$RUN_CACHE" = true ]; then
    step "Cache de paquets"
    if [ "$MODE" = "check" ]; then
        size=$(du -sh /var/cache/zypp 2>/dev/null | cut -f1)
        ok "Cache actuel : ${size:-inconnu} (rien n'a été supprimé)"
    else
        size=$(du -sh /var/cache/zypp 2>/dev/null | cut -f1)
        if zypper clean --all; then
            ok "Cache nettoyé (${size:-?} libérés)"
        else
            error "Échec du nettoyage du cache"
        fi
    fi
fi

# --- 4. Orphelins ---
if [ "$RUN_ORPHANS" = true ]; then
    step "Paquets orphelins"
    orphans=$(zypper packages --orphaned 2>/dev/null | grep -c '^i')
    if [ "$orphans" -gt 0 ]; then
        warn "$orphans paquet(s) orphelin(s) détecté(s) :"
        zypper packages --orphaned | grep '^i'
        echo "Pour en supprimer un : sudo zypper remove <nom-du-paquet>"
    else
        ok "Aucun paquet orphelin"
    fi
fi

# --- 5. Services à redémarrer ---
if [ "$RUN_SERVICES" = true ]; then
    step "Services à redémarrer"
    services=$(zypper ps -s 2>/dev/null)
    # Décision sur la sortie anglaise (LC_ALL=C) : le texte affiché, lui, suit la langue de l'utilisateur
    if LC_ALL=C zypper ps -s 2>/dev/null | grep -q "^No processes using deleted files"; then
        ok "Aucun service à redémarrer"
    else
        warn "Ces services utilisent d'anciennes bibliothèques et devraient redémarrer :"
        echo "$services"
    fi
fi

# --- 6. Redémarrage nécessaire ? ---
if [ "$RUN_REBOOT" = true ]; then
    step "Redémarrage nécessaire ?"
    if zypper needs-rebooting; then
        ok "Aucun redémarrage nécessaire"
    else
        warn "Un redémarrage est recommandé (noyau ou composant critique mis à jour)"
    fi
fi

# --- 7. Snapshots Snapper ---
if [ "$RUN_SNAPSHOTS" = true ]; then
    step "Snapshots Snapper"
    if command -v snapper &> /dev/null; then
        before=$(snapper list 2>/dev/null | grep -c '^[0-9]')
        if [ "$MODE" = "check" ]; then
            ok "$before snapshot(s) actuellement (rien n'a été supprimé)"
        else
            snapper cleanup number
            snapper cleanup timeline
            after=$(snapper list 2>/dev/null | grep -c '^[0-9]')
            ok "Snapshots : $before → $after"
        fi
    else
        warn "snapper n'est pas installé — étape ignorée"
    fi
fi

# --- Avertissements TPM repérés dans la sortie des mises à jour ---
if grep -qiE "$TPM_PATTERN" "$RUN_OUT" 2>/dev/null; then
    step "Chiffrement du disque (TPM)"
    warn "Le déverrouillage automatique du disque (TPM) n'a pas pu être mis à jour."
    echo "   Au prochain redémarrage, la clé de récupération sera probablement demandée."
    echo "   Ensuite, réinscrivez la puce TPM (voir la documentation sdbootutil)."
    mkdir -p "$STATUS_DIR"
    cat /proc/sys/kernel/random/boot_id > "$STATUS_DIR/tpm-warning"
fi
rm -f "$RUN_OUT"

# --- Mise à jour du fichier d'état pour l'icône système ---
write_status false

# --- Résumé ---
echo -e "\n${BLUE}=========================================="
echo -e "   Résumé"
echo -e "==========================================${NC}"
if [ "$ERRORS" -eq 0 ] && [ "$WARNINGS" -eq 0 ]; then
    echo -e "${GREEN}Tout est en ordre.${NC}"
elif [ "$ERRORS" -eq 0 ]; then
    echo -e "${YELLOW}$WARNINGS avertissement(s), aucune erreur.${NC}"
else
    echo -e "${RED}$ERRORS erreur(s), $WARNINGS avertissement(s).${NC}"
fi

[ "$ERRORS" -eq 0 ] && exit 0 || exit 1
