#!/usr/bin/bash
#
# kemmos-update — Outil de maintenance système pour KemmOS
# Version 1.8.0 (messages en français, en breton et en anglais)
#
# Usage : sudo kemmos-update [options]   (voir --help)

LOGFILE="/var/log/kemmos-update.log"
STATUS_DIR="/var/lib/kemmos-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
DEBLOQUER=false   # --debloquer : retire les paquets ajoutés qui bloquent zypper dup, si c'est sans risque (1.7.0)
DOCTEUR=/usr/share/kemmos-update/docteur.py
PRUDENT=/usr/share/kemmos-update/prudent.py   # mises à jour prudentes (1.8.0)
PRUDENT_REGLER=""                             # --prudent=oui|non
RETOUR=/usr/libexec/kemmos-update/retour-auto # retour automatique si le démarrage échoue (1.8.0)
ARGS_ORIG=("$@")   # options d'origine, pour la relance après mise à jour de KemmOS-Update (1.6.1)

# --- 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

# --- Langue des messages (1.6.0) : français (textes d'origine), breton (repli sur le français), anglais pour
#     toutes les autres langues. pkexec vide l'environnement : l'icône système passe --langue=<code>.
#     gettext ignore LANGUAGE sous la locale C (et C.UTF-8) : les messages sont traduits avec en_US.UTF-8
#     (glibc-locale-base, toujours présente) ; zypper, fwupd, snapper gardent leur propre langue.
MSG_LANG=""
code_langue() {
    local v
    for v in "$LANGUAGE" "$LC_ALL" "$LC_MESSAGES" "$LANG"; do
        if [ -n "$v" ]; then
            v=${v%%:*}; v=${v%%.*}; v=${v%%@*}
            echo "${v%%_*}"
            return
        fi
    done
    echo fr
}
choisir_langue() {
    case "$1" in
        fr|C|POSIX|"") MSG_LANG="" ;;
        br) MSG_LANG=br ;;
        *) MSG_LANG=en ;;
    esac
}
choisir_langue "$(code_langue)"
# _ "texte" : texte traduit ; _f "format %s" valeurs… : printf du format traduit
_() {
    if [ -n "$MSG_LANG" ]; then
        LC_ALL=en_US.UTF-8 LANGUAGE=$MSG_LANG TEXTDOMAINDIR=${KEMMOS_LOCALE:-/usr/share/locale} \
            gettext -d kemmos-update -- "$1" 2>/dev/null || printf '%s' "$1"
    else
        printf '%s' "$1"
    fi
}
_f() {
    local fmt
    fmt=$(_ "$1")
    shift
    # shellcheck disable=SC2059
    printf "$fmt" "$@"
}

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 PackageKit (logithèque, mises à jour automatiques) qui vérifie les mises à jour.")"
    echo "   $(_ "Attendez qu'il ait fini puis relancez KemmOS-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
}

# --- Docteur des mises à jour (1.7.0) ---
# Sortie anglaise de « zypper dup --dry-run » (quelle que soit la langue de la session) → fichier $1
dup_simulation_c() {
    LC_ALL=C zypper --non-interactive dup --dry-run --auto-agree-with-licenses > "$1" 2>&1
}
# Analyse du blocage par docteur.py : JSON sur la sortie standard (voir docteur.py)
docteur() {
    python3 "${KEMMOS_DOCTEUR:-$DOCTEUR}" "$1" 2>/dev/null
}
# Champ du JSON $1 : liste → éléments séparés par des espaces ; vrai → « oui » ; faux → vide
docteur_champ() {
    python3 -c 'import json, sys
try:
    v = json.load(open(sys.argv[1])).get(sys.argv[2])
except Exception:
    v = None
print(" ".join(v) if isinstance(v, list) else ("oui" if v is True else (v or "")))' "$1" "$2" 2>/dev/null
}
# Explications : « paquet ⟶ exigence introuvable », une par ligne
docteur_besoins() {
    python3 -c 'import json, sys
try:
    for paquet, besoin in json.load(open(sys.argv[1])).get("besoins", [])[:6]:
        print(paquet + "\t" + besoin)
except Exception:
    pass' "$1" 2>/dev/null
}
docteur_explique() {
    local paquet besoin
    while IFS=$'\t' read -r paquet besoin; do
        [ -n "$paquet" ] && echo "   • $(_f "%s a besoin de %s, introuvable dans les dépôts actuels" "$paquet" "$besoin")"
    done < <(docteur_besoins "$1")
}

# zypper s'est arrêté (code 4) sur un conflit entre paquets : il attend un choix
zypp_problem_msg() {
    local c j
    error "$(_ "Mise à jour bloquée : zypper demande de choisir entre plusieurs solutions (conflit entre paquets)")"
    problem_text < "$1" | sed 's/^/   /'
    c=$(mktemp); j=$(mktemp)
    dup_simulation_c "$c"
    docteur "$c" > "$j"
    if [ "$(docteur_champ "$j" sur)" = oui ]; then
        echo "   $(_ "Cause : les dépôts openSUSE ne sont pas encore cohérents (problème passager, pas votre ordinateur).")"
        docteur_explique "$j"
        echo "   $(_ "KemmOS-Update peut débloquer la mise à jour sans risque en retirant ces paquets, ajoutés après l'installation (aucun ne fait partie de KemmOS) :")"
        echo "      $(docteur_champ "$j" cascade)"
        echo "   $(_ "Pour cela : sudo kemmos-update --debloquer (ou « Mettre à jour et nettoyer » dans l'icône KemmOS-Update)")"
    else
        echo "   $(_ "KemmOS-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.")"
    fi
    rm -f "$c" "$j"
}

# --debloquer : retire les paquets qui bloquent zypper dup quand le Docteur juge que c'est sans risque.
# Plusieurs tours (zypper ne détaille qu'un problème à la fois), 15 paquets au plus en tout.
debloquer() {
    local tour c j retirer cascade total=0 retires=""
    for tour in 1 2 3; do
        c=$(mktemp); j=$(mktemp)
        dup_simulation_c "$c"
        if ! grep -q '^Problem' "$c"; then
            rm -f "$c" "$j"
            [ "$tour" = 1 ] && ok "$(_ "Rien à débloquer : la mise à jour n'est pas bloquée")"
            break
        fi
        docteur "$c" > "$j"
        retirer=$(docteur_champ "$j" retirer)
        cascade=$(docteur_champ "$j" cascade)
        total=$(( total + $(wc -w <<< "$cascade") ))
        if [ "$(docteur_champ "$j" sur)" != oui ] || [ "$total" -gt 15 ]; then
            warn "$(_ "Déblocage automatique impossible sans risque (il faudrait retirer des éléments de KemmOS, ou zypper ne propose pas de retrait)")"
            rm -f "$c" "$j"
            break
        fi
        echo "$(_ "Déblocage : les dépôts openSUSE ne sont pas encore cohérents (problème passager).")"
        docteur_explique "$j"
        echo "$(_f "Retrait de : %s" "$cascade")"
        rm -f "$c" "$j"
        # shellcheck disable=SC2086
        zypper --non-interactive remove --no-clean-deps $retirer 2>&1 | tee -a "$RUN_OUT"
        if [ "${PIPESTATUS[0]}" -ne 0 ]; then
            error "$(_ "Le retrait a échoué : déblocage abandonné")"
            break
        fi
        retires="$retires $cascade"
    done
    if [ -n "$retires" ]; then
        mkdir -p "$STATUS_DIR"
        echo "$(date '+%Y-%m-%d %H:%M:%S')$retires" >> "$STATUS_DIR/retires.log"
        ok "$(_f "Mise à jour débloquée. Paquets retirés :%s" "$retires")"
        echo "   $(_ "Vous pourrez les réinstaller dans quelques jours, quand les dépôts seront de nouveau cohérents :")"
        echo "      sudo zypper install$retires"
    fi
}

# --- Mises à jour prudentes (1.8.0) ---
# Les dépôts oss / non-oss de Tumbleweed suivent une version âgée d'au moins 3 jours (copie datée d'openSUSE,
# download.opensuse.org/history), jamais plus ancienne que le système installé ni dans la liste des versions à
# éviter (paquet kemmos-prudence). Voir prudent.py. $1 = « bavard » pour afficher le résultat.
date_lisible() {   # 20261013 → 13/10/2026
    sed -E 's#^([0-9]{4})([0-9]{2})([0-9]{2})$#\3/\2/\1#' <<< "$1"
}
prudence() {
    local j version derniere raison actif
    [ -f "${KEMMOS_PRUDENT:-$PRUDENT}" ] || return 0
    j=$(python3 "${KEMMOS_PRUDENT:-$PRUDENT}" appliquer 2>/dev/null) || return 0
    [ "$1" = bavard ] || return 0
    champ() { python3 -c 'import json,sys; v=json.loads(sys.argv[1]).get(sys.argv[2]); print("oui" if v is True else ("" if v is False else v))' "$j" "$1" 2>/dev/null; }
    actif=$(champ actif); version=$(champ version); derniere=$(champ derniere); raison=$(champ raison)
    case "$raison" in
        fige|fige-evitee)
            ok "$(_f "Mode prudent : Tumbleweed du %s (%s jours de recul au moins ; dernière version publiée : %s)" \
                "$(date_lisible "$version")" "$(champ delai)" "$(date_lisible "$derniere")")"
            [ "$raison" = fige-evitee ] && \
                echo "   $(_ "Votre système est sur une version signalée à éviter : il passera à la suivante dès qu'elle aura assez de recul.")" ;;
        hors-ligne)
            warn "$(_ "Mode prudent : le serveur d'openSUSE ne répond pas, réglage des dépôts inchangé")" ;;
        desactive)
            echo "$(_ "Mode prudent désactivé : dernière version de Tumbleweed")" ;;
        direct)
            [ "$actif" = oui ] && echo "$(_ "Mode prudent : aucune version assez ancienne disponible, dernière version de Tumbleweed")" ;;
    esac
    unset -f champ
}

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

# 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 "$(_f "Espace disque insuffisant : %s libres, %s nécessaires (marge de 3 Go comprise)" "$(human "$avail")" "$(human "$need")")"
        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() {
_f "KemmOS-Update — outil de maintenance système pour KemmOS

Usage : sudo %s [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 %s
                    (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
  --debloquer       Si la mise à jour est bloquée par des paquets ajoutés après l'installation,
                    les retire (seulement si c'est sans risque pour KemmOS), puis met à jour
  --prudent=oui|non Mises à jour prudentes : suivre Tumbleweed avec 3 jours de recul (oui, par défaut)
                    ou la toute dernière version (non) ; règle les dépôts puis s'arrête
  --langue=CODE     Langue des messages : fr, br ou en (par défaut, celle de la session)
  --no-log          Désactive l'écriture dans le fichier de log (%s)
  -h, --help        Affiche cette aide

Sans option de sélection d'étape, toutes les étapes sont exécutées.
" "$0" "$STATUS_FILE" "$LOGFILE"
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)

    # Mode prudent : dépôts réglés sur la bonne version de Tumbleweed avant la simulation (1.8.0)
    prudence
    # 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, KemmOS 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
        dup_simulation_c "$tmp/dup-c.txt"
        problem_text < "$tmp/dup-c.txt" > "$tmp/problem.txt"
        # Docteur des mises à jour (1.7.0) : déblocage possible sans risque ?
        docteur "$tmp/dup-c.txt" > "$tmp/docteur.json"
    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 /
    "deblocage": {},                   # analyse du Docteur quand la mise à jour est bloquée (1.7.0)
    "prudent": {},                     # mises à jour prudentes : version de Tumbleweed suivie (1.8.0)
}
try:
    with open(os.path.join(os.path.dirname(status_file), "prudent.json")) as f:
        status["prudent"] = json.load(f)
except Exception:
    pass

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
    try:
        with open(os.path.join(tmp, "docteur.json")) as f:
            status["deblocage"] = json.load(f)
    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 ;;
        --debloquer)  DEBLOQUER=true ;;
        --prudent=oui|--prudent=non) PRUDENT_REGLER="${1#--prudent=}" ;;
        --langue=*)   choisir_langue "${1#--langue=}" ;;
        --no-log)     DO_LOG=false ;;
        -h|--help)    SHOW_HELP=true ;;
        *)
            echo -e "${RED}✗ $(_ "Option inconnue :") $1${NC}"
            echo "$(_ "Utilisez --help pour la liste des options.")"
            exit 1
            ;;
    esac
    shift
done

# aide affichée après lecture de toutes les options (--langue peut venir après --help)
[ "$SHOW_HELP" = true ] && usage

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 "$(_f "Utilisation : sudo %s [options] (voir --help)" "$0")"
    exit 1
fi

# --- Réglage du mode prudent (Centre KemmOS), puis on s'arrête ---
if [ -n "$PRUDENT_REGLER" ]; then
    python3 "${KEMMOS_PRUDENT:-$PRUDENT}" regler "$PRUDENT_REGLER" >/dev/null 2>&1
    prudence bavard
    exit 0
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') — KemmOS-Update (mode: $MODE) ###"
fi

RUN_OUT=$(mktemp)

echo -e "${BLUE}=========================================="
echo -e "   $(_f "KemmOS-Update — Maintenance KemmOS (mode : %s)" "$MODE")"
echo -e "==========================================${NC}"

# --- 0. KemmOS-Update lui-même (1.6.1) ---
# Mis à jour seul, juste avant zypper dup, puis relancé : une nouvelle version peut ainsi contourner un blocage
# de zypper dup (dépendances cassées dans Tumbleweed, ex. numba/llvmlite en octobre 2026) qui, sinon,
# bloquerait aussi sa propre mise à jour. « zypper update <paquet> » ne touche qu'à ce paquet et à ses
# dépendances : il passe même quand dup est bloqué. Échec sans conséquence (dup suit normalement).
if [ "$RUN_SYSTEM" = true ] && [ "$MODE" = "apply" ] && [ -z "${KEMMOS_UPDATE_RELANCE:-}" ]; then
    ku_avant=$(rpm -q --qf '%{VERSION}-%{RELEASE}' kemmos-update 2>/dev/null)
    ZYPP_LOCK_TIMEOUT=120 zypper --non-interactive update --no-recommends --auto-agree-with-licenses kemmos-update kemmos-prudence >/dev/null 2>&1
    ku_apres=$(rpm -q --qf '%{VERSION}-%{RELEASE}' kemmos-update 2>/dev/null)
    if [ -n "$ku_apres" ] && [ "$ku_avant" != "$ku_apres" ] && [ -x /usr/bin/kemmos-update ]; then
        ok "$(_f "KemmOS-Update mis à jour (%s → %s) : la suite se fait avec la nouvelle version" "$ku_avant" "$ku_apres")"
        rm -f "$RUN_OUT"
        # --no-log : la sortie passe déjà par le journal de ce processus (sinon chaque ligne y serait écrite deux fois)
        if [ "$DO_LOG" = true ]; then set -- "${ARGS_ORIG[@]}" --no-log; else set -- "${ARGS_ORIG[@]}"; fi
        KEMMOS_UPDATE_RELANCE=1 exec /usr/bin/kemmos-update "$@"
    fi
fi

# --- 1. Système ---
if [ "$RUN_SYSTEM" = true ]; then
    step "$(_ "Mise à jour du système (zypper dup)")"
    # Mode prudent (1.8.0) : version de Tumbleweed à suivre (liste des versions à éviter tout juste mise à jour)
    if [ "$MODE" = "apply" ]; then
        prudence bavard
        zypper --non-interactive --quiet refresh >/dev/null 2>&1
    fi
    # 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 "$(_f "Gestion des paquets occupée (%s) — attente (2 min maximum)…" "$(zypp_holder)")"
    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)
        # Retrait éventuel avant dup : son snapshot « pre » devient le point de restauration (état d'avant tout)
        [ "$DEBLOQUER" = true ] && debloquer
        # 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
                # TRANSLATORS: garder « snapshot %s » tel quel : l'icône système y lit le numéro
                ok "$(_f "Point de restauration : snapshot %s (état d'avant la mise à jour)" "$restore")"
                echo "   $(_f "En cas de problème : au démarrage, menu GRUB « Start bootloader from a read-only snapshot », choisir le n° %s, puis accepter la restauration proposée." "$restore")"
                # Retour automatique (1.8.0) : si les deux prochains démarrages échouent, GRUB démarre ce snapshot
                if [ -x "$RETOUR" ] && "$RETOUR" armer "$restore" >/dev/null 2>&1; then
                    echo "   $(_ "Si l'ordinateur n'arrive plus à démarrer deux fois de suite, il reviendra tout seul à cet état.")"
                fi
            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 "$(_f "La mise à jour du système a rencontré un problème (zypper, code %s)" "$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 "$(_f "Mise à jour firmware sensible (%s) sur un disque chiffré par TPM :" "$sensitive")"
                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 "$(_f "Cache actuel : %s (rien n'a été supprimé)" "${size:-?}")"
    else
        size=$(du -sh /var/cache/zypp 2>/dev/null | cut -f1)
        if zypper clean --all; then
            ok "$(_f "Cache nettoyé (%s libérés)" "${size:-?}")"
        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 "$(_f "%s paquet(s) orphelin(s) détecté(s) :" "$orphans")"
        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 "$(_f "%s snapshot(s) actuellement (rien n'a été supprimé)" "$before")"
        else
            snapper cleanup number
            snapper cleanup timeline
            after=$(snapper list 2>/dev/null | grep -c '^[0-9]')
            ok "$(_f "Snapshots : %s → %s" "$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}$(_f "%s avertissement(s), aucune erreur." "$WARNINGS")${NC}"
else
    echo -e "${RED}$(_f "%s erreur(s), %s avertissement(s)." "$ERRORS" "$WARNINGS")${NC}"
fi

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