#!/usr/bin/env bash
set -euo pipefail

APT_CONF="/etc/auxinux/apt.conf"
# Installation d'APPLICATIONS en DEB (Center et `auxi install` sans option).
# Distinct d'APT_CONF: on peut vouloir des applications DEB tout en gardant
# apt/apt-get renvoyes vers auxi et son point de restauration.
APPS_CONF="/etc/auxinux/apps.conf"
APT_REAL_DIR="/usr/lib/auxinux/apt-real"
SNAPPER_CONFIG="root"
BTRFS_TOPLEVEL_MNT="/run/auxinux-btrfs-toplevel"
SNAPSHOT_OVERLAY_LOWER="/run/auxinux-snapshot/lower"

# Langue des messages: la PREMIERE preference, comme gettext (LANGUAGE, puis
# LC_ALL, LC_MESSAGES, LANG). LANGUAGE est une liste de REPLI
# (« fr_CA:fr:en_CA:en », posee par l'image pour tout le monde): y chercher
# « en » n'importe ou affichait l'anglais a tous les francophones (constate en
# VM le 2026-10-08).
is_english() {
  local lang="${LANGUAGE:-}"
  lang="${lang%%:*}"
  [[ -n "${lang}" ]] || lang="${LC_ALL:-${LC_MESSAGES:-${LANG:-}}}"
  [[ "${lang}" == en || "${lang}" == en_* || "${lang}" == en.* ]]
}

say() {
  local fr="$1"
  local en="$2"
  if is_english; then
    printf '%s\n' "${en}"
  else
    printf '%s\n' "${fr}"
  fi
}

say_err() {
  local fr="$1"
  local en="$2"
  if is_english; then
    printf '%s\n' "${en}" >&2
  else
    printf '%s\n' "${fr}" >&2
  fi
}

usage() {
  if is_english; then
    cat <<'EOF'
auxi - AuxiNux OS administration command

Usage:
  auxi [--yes] [--progress] COMMAND ...
  auxi update [--deb|--flatpak]
  auxi upgrade [--deb|--flatpak]
  auxi os update
  auxi os upgrade
  auxi kernel [list [--porcelain]]
  auxi kernel install|activate|remove VERSION
  auxi kernel activate latest
  auxi kernel update
  auxi kernel dev on|off
  auxi search [--deb|--flatpak] TERM
  auxi install [--deb|--flatpak] PACKAGE_OR_APP...
  auxi uninstall [--deb|--flatpak] PACKAGE_OR_APP
  auxi purge PACKAGE
  auxi clean
  auxi autoclean
  auxi snapshot [DESCRIPTION]
  auxi snapshots
  auxi rollback [NUMBER] [--yes]
  auxi rollback-cleanup [--yes]
  auxi set apt=true|false
  auxi set deb=true|false
  auxi status

Applications are installed from Flatpak (Flathub). DEB installation is only
used when enabled (auxi set deb=true), and even then only when no Flatpak
exists for the requested application.

os update tells whether a new AuxiNux OS version is available; os upgrade
installs it with every system DEB package (kernels included), after a named
snapshot. Neither, nor kernel, depends on that setting.

Global options (before the command):
  --yes       answer yes to every question, keep modified configuration files
  --progress  also print machine-readable progress lines (apt Status-Fd)
EOF
  else
    cat <<'EOF'
auxi - commande d'administration AuxiNux OS

Usage:
  auxi [--yes] [--progress] COMMANDE ...
  auxi update [--deb|--flatpak]
  auxi upgrade [--deb|--flatpak]
  auxi os update
  auxi os upgrade
  auxi kernel [list [--porcelain]]
  auxi kernel install|activate|remove VERSION
  auxi kernel activate latest
  auxi kernel update
  auxi kernel dev on|off
  auxi search [--deb|--flatpak] TERME
  auxi install [--deb|--flatpak] PAQUET_OU_APP...
  auxi uninstall [--deb|--flatpak] PAQUET_OU_APP
  auxi purge PAQUET
  auxi clean
  auxi autoclean
  auxi snapshot [DESCRIPTION]
  auxi snapshots
  auxi rollback [NUMÉRO] [--yes]
  auxi rollback-cleanup [--yes]
  auxi set apt=true|false
  auxi set deb=true|false
  auxi status

Les applications s'installent depuis Flatpak (Flathub). L'installation DEB
n'est utilisée que si elle est activée (auxi set deb=true), et même alors
seulement quand aucun Flatpak n'existe pour l'application demandée.

os update dit si une nouvelle version d'AuxiNux OS est disponible; os upgrade
l'installe avec tous les paquets DEB du système (noyaux compris), après un
instantané nommé. Ni l'un ni l'autre, ni kernel, ne dépend de ce réglage.

Options globales (avant la commande):
  --yes       répond oui à toutes les questions, garde les fichiers de
              configuration modifiés
  --progress  ajoute des lignes d'avancement lisibles par un programme
              (Status-Fd d'apt)
EOF
  fi
}

# Dans un terminal, une commande qui exige root se relance d'elle-meme par
# sudo au lieu d'echouer.
#
# PANNE A L'ORIGINE (2026-10-09, aporler): « que ce soit en ligne de commande
# ou dans l'interface, les mises a jour doivent fonctionner ». Le message
# d'apt propose `auxi update` et `auxi upgrade` SANS sudo; ces commandes
# faisaient la partie Flatpak puis s'arretaient sur « Les operations DEB
# doivent etre executees avec sudo ». Le systeme n'etait pas mis a jour.
#
# Seulement avec un terminal (sudo y demande le mot de passe) et la meme ligne
# de commande, options globales comprises. Le centre de controle passe par
# pkexec et n'est pas concerne. AUXI_NO_SUDO=1 coupe ce relais (tests).
AUXI_ARGS=("$@")
elevate_or_continue() {
  [[ "${EUID}" -ne 0 ]] || return 0
  [[ "${AUXI_NO_SUDO:-0}" != "1" ]] || return 0
  [[ -t 0 && -t 2 ]] || return 0
  command -v sudo >/dev/null 2>&1 || return 0
  local self
  self="$(readlink -f "${BASH_SOURCE[0]}" 2>/dev/null || printf '%s' "${BASH_SOURCE[0]}")"
  say_err \
    "Droits administrateur nécessaires: sudo auxi ${AUXI_ARGS[*]}" \
    "Administrator rights needed: sudo auxi ${AUXI_ARGS[*]}"
  exec sudo -- "${self}" "${AUXI_ARGS[@]}"
}

require_root_for_config() {
  elevate_or_continue
  if [[ "${EUID}" -ne 0 ]]; then
    say_err \
      "Cette action doit être exécutée avec sudo: sudo auxi $*" \
      "This action must be run with sudo: sudo auxi $*"
    exit 1
  fi
}

require_root_for_deb() {
  elevate_or_continue
  if [[ "${EUID}" -ne 0 ]]; then
    say_err \
      "Les opérations DEB doivent être exécutées avec sudo." \
      "DEB operations must be run with sudo."
    say_err \
      "Exemple: sudo auxi $*" \
      "Example: sudo auxi $*"
    exit 1
  fi
}

apt_real() {
  # Toujours appeler le vrai binaire APT directement.
  # Ne jamais retomber sur command -v: cela resoudrait le wrapper
  # /usr/bin/apt-get qui, avec APT_ENABLED=0, bloquerait auxi lui-meme.
  local name="$1"
  if [[ -x "${APT_REAL_DIR}/${name}" ]]; then
    echo "${APT_REAL_DIR}/${name}"
  else
    say_err \
      "Binaire APT introuvable: ${APT_REAL_DIR}/${name}" \
      "APT binary not found: ${APT_REAL_DIR}/${name}"
    say_err \
      "Installation auxi incomplète; vérifiez install-auxi-cli.sh." \
      "Incomplete auxi installation; check install-auxi-cli.sh."
    exit 70
  fi
}

# apt-cache N'EST PLUS detourne (lecture seule, voir install-auxi-cli.sh):
# /usr/lib/auxinux/apt-real/apt-cache n'existe pas sur un systeme installe, et
# `apt_real apt-cache` y sortait en 70 -- `auxi search --deb` echouait donc
# toujours. On garde le binaire detourne s'il existe (rootfs ancien).
apt_cache() {
  if [[ -x "${APT_REAL_DIR}/apt-cache" ]]; then
    "${APT_REAL_DIR}/apt-cache" "$@"
  else
    command apt-cache "$@"
  fi
}

# apt-get avec les options globales de `auxi`.
#
# --yes N'EST PAS UN CONFORT: c'est ce qui permet au centre de controle de
# mettre le systeme a jour. Il lance `auxi` par pkexec, sans terminal, l'entree
# standard sur /dev/null. Sans -y, apt-get posait sa question « Continuer ?
# [O/n] », lisait une fin de fichier, repondait « Abandon. » et sortait en 1 --
# sur la sortie STANDARD, que l'interface ne montrait pas. L'utilisateur voyait
# « Echec de l'operation » apres plusieurs minutes, sans aucune explication.
# Meme chose pour toute desinstallation, et pour toute installation qui tire
# une dependance.
#
# Sans terminal, aucune autre question ne peut recevoir de reponse non plus:
#   - debconf: frontend noninteractive, les valeurs par defaut s'appliquent;
#   - dpkg et un fichier de configuration modifie localement (c'est le cas de
#     /etc/issue, que l'image remplace): --force-confold garde la version
#     installee, --force-confdef laisse dpkg trancher seul quand il le peut.
#     Sans ces options, dpkg echoue sur « EOF on stdin at conffile prompt » au
#     milieu de la transaction.
#
# --progress ajoute les lignes « dlstatus: » et « pmstatus: » d'apt sur la
# sortie standard (pkexec ferme tout descripteur au-dela de 2, d'ou le 1).
# C'est ce que le centre de controle lit pour afficher sa barre de progression.
apt_get() {
  local bin
  bin="$(apt_real apt-get)"
  local opts=()
  if [[ "${ASSUME_YES}" -eq 1 ]]; then
    opts+=(-y -o "Dpkg::Options::=--force-confdef" -o "Dpkg::Options::=--force-confold")
  fi
  if [[ "${PROGRESS}" -eq 1 ]]; then
    opts+=(-o "APT::Status-Fd=1")
  fi
  "${bin}" "${opts[@]}" "$@"
}

# Options communes de flatpak: -y en toutes circonstances (c'etait deja le cas),
# et une sortie sans tableau anime quand personne n'est la pour la lire.
flatpak_opts() {
  FLATPAK_OPTS=(-y)
  if [[ "${ASSUME_YES}" -eq 1 ]]; then
    FLATPAK_OPTS+=(--noninteractive)
  fi
}

apt_enabled() {
  [[ -r "${APT_CONF}" ]] && grep -Eq '^APT_ENABLED=1$' "${APT_CONF}"
}

deb_apps_enabled() {
  [[ -r "${APPS_CONF}" ]] && grep -Eq '^DEB_APPS=1$' "${APPS_CONF}"
}

set_deb_apps() {
  require_root_for_config set "deb=$1"
  install -d -m 0755 /etc/auxinux
  case "$1" in
    true|1|yes)
      printf 'DEB_APPS=1\n' >"${APPS_CONF}"
      say \
        "Installation DEB activée. Flatpak reste prioritaire: le DEB ne sert que si aucun Flatpak n'existe." \
        "DEB installation enabled. Flatpak stays first: DEB is used only when no Flatpak exists."
      ;;
    false|0|no)
      printf 'DEB_APPS=0\n' >"${APPS_CONF}"
      say \
        "Installation DEB désactivée: les applications s'installent depuis Flatpak." \
        "DEB installation disabled: applications are installed from Flatpak."
      ;;
    *)
      say_err "Valeur invalide: deb=$1" "Invalid value: deb=$1"
      exit 64
      ;;
  esac
}

deb_installed() {
  dpkg-query -W -f='${Status}' -- "$1" 2>/dev/null | grep -q 'install ok installed'
}

deb_disabled_hint() {
  say_err \
    "L'installation DEB est désactivée. Pour l'activer: sudo auxi set deb=true (ou Réglages du centre AuxiNux)." \
    "DEB installation is disabled. To enable it: sudo auxi set deb=true (or the AuxiNux Center settings)."
}

# Forme comparable d'un nom: minuscules, lettres et chiffres seulement.
# « OBS Studio », « obs-studio » et « obsstudio » se rejoignent.
normalize_name() {
  local s="${1,,}"
  printf '%s' "${s//[^a-z0-9]/}"
}

# Identifiant Flathub d'une application demandee par son nom.
#
# `auxi install gimp` installait le DEB: seul un identifiant EXACT
# (org.gimp.GIMP) etait reconnu comme Flatpak. On accepte desormais, sans
# tenir compte de la casse ni des tirets: l'identifiant complet, son dernier
# composant (org.gimp.GIMP -> gimp) ou le nom affiche (« OBS Studio »). Les
# greffons (org.gimp.GIMP.Plugin.*) et manuels ne correspondent pas: leur
# dernier composant et leur nom different. Rien n'est devine au-dela: sans
# correspondance exacte, aucune application n'est choisie a la place de
# l'utilisateur.
#
# $1: terme demande; lit la sortie de `flatpak search --columns=
# application,name,remotes` sur l'entree standard.
pick_flatpak_id() {
  local want id name remotes tail
  want="$(normalize_name "$1")"
  [[ -n "${want}" ]] || return 1
  while IFS=$'\t' read -r id name remotes; do
    [[ "${id}" == *.* ]] || continue
    [[ ",${remotes// /}," == *,flathub,* ]] || continue
    tail="${id##*.}"
    if [[ "$(normalize_name "${id}")" == "${want}" \
          || "$(normalize_name "${tail}")" == "${want}" \
          || "$(normalize_name "${name}")" == "${want}" ]]; then
      printf '%s\n' "${id}"
      return 0
    fi
  done
  return 1
}

resolve_flatpak() {
  local term="$1"
  if flatpak remote-ls flathub --app --columns=application 2>/dev/null | grep -Fxq -- "${term}"; then
    printf '%s\n' "${term}"
    return 0
  fi
  flatpak search --columns=application,name,remotes -- "${term}" 2>/dev/null \
    | pick_flatpak_id "${term}"
}

# Applications Flathub proches de $1, quand aucune ne correspond exactement.
show_flatpak_suggestions() {
  local shown=0 id name remotes
  while IFS=$'\t' read -r id name remotes; do
    [[ "${id}" == *.* && ",${remotes// /}," == *,flathub,* ]] || continue
    [[ "${shown}" -eq 0 ]] && say "Applications Flatpak proches:" "Close Flatpak applications:"
    printf '  %-40s %s\n' "${id}" "${name}"
    shown=$((shown + 1))
    [[ "${shown}" -ge 8 ]] && break
  done < <(flatpak search --columns=application,name,remotes -- "$1" 2>/dev/null || true)
  if [[ "${shown}" -gt 0 ]]; then
    say "Installez-en une par son identifiant: auxi install IDENTIFIANT" \
        "Install one by its identifier: auxi install IDENTIFIER"
  fi
}

set_apt() {
  require_root_for_config set "apt=$1"
  install -d -m 0755 /etc/auxinux
  case "$1" in
    true|1|yes)
      printf 'APT_ENABLED=1\n' >"${APT_CONF}"
      say \
        "APT direct réactivé. La commande recommandée reste auxi." \
        "Direct APT re-enabled. The recommended command remains auxi."
      ;;
    false|0|no)
      printf 'APT_ENABLED=0\n' >"${APT_CONF}"
      say \
        "APT direct masqué. Utilisez auxi pour les opérations utilisateur." \
        "Direct APT hidden. Use auxi for user package operations."
      ;;
    *)
      say_err \
        "Valeur invalide: apt=$1" \
        "Invalid value: apt=$1"
      exit 64
      ;;
  esac
}

# --- Instantanes systeme (BTRFS + snapper) ---------------------------------
#
# Tout ce bloc doit se degrader silencieusement: une racine ext4, un snapper
# absent ou une session live n'ont pas d'instantanes, et cela ne doit JAMAIS
# empecher une installation de paquet d'aboutir.

# Vrai quand le systeme a demarre sur un instantane depuis le menu GRUB. Dans
# ce cas la racine visible est un overlay (voir le hook initramfs
# auxinux-snapshot-overlay): interroger "/" renverrait « overlay » et le nom de
# peripherique « auxinux-snapshot ». C'est PRECISEMENT la situation ou l'on a
# besoin de `auxi rollback`, et sans cette distinction la commande refusait de
# s'executer.
booted_from_snapshot() {
  [[ -d "${SNAPSHOT_OVERLAY_LOWER}" ]] || return 1
  grep -qw 'auxinux.snapshot=1' /proc/cmdline 2>/dev/null
}

# Point de montage a interroger pour connaitre le VRAI systeme de fichiers
# racine, instantane compris.
root_mount_ref() {
  if booted_from_snapshot; then
    printf '%s' "${SNAPSHOT_OVERLAY_LOWER}"
  else
    printf '/'
  fi
}

snapshots_available() {
  command -v snapper >/dev/null 2>&1 || return 1
  [[ "$(findmnt -no FSTYPE "$(root_mount_ref)" 2>/dev/null)" == "btrfs" ]] || return 1
  [[ -f "/etc/snapper/configs/${SNAPPER_CONFIG}" ]] || return 1
  return 0
}

require_snapshots() {
  if snapshots_available; then
    return 0
  fi
  say_err \
    "Les instantanés ne sont pas disponibles sur ce système." \
    "Snapshots are not available on this system."
  say_err \
    "Ils exigent une racine BTRFS avec snapper configuré (voir docs/rollback.md)." \
    "They require a BTRFS root with snapper configured (see docs/rollback.md)."
  exit 69
}

# Les instantanes automatiques ne sont PLUS poses ici.
#
# Ils le sont par /usr/lib/auxinux/apt-snapshot-hook, branche sur DPkg::Pre-
# Invoke et DPkg::Post-Invoke (voir /etc/apt/apt.conf.d/80auxinux-snapshot).
# Tant que la logique vivait dans `auxi`, toute autre voie vers dpkg -- `apt`
# reactive par `auxi set apt=true`, PackageKit, un script tiers -- modifiait le
# systeme sans filet, alors que l'interface affirmait le contraire. Attache a
# dpkg, l'instantane couvre desormais tous les chemins, `auxi` compris: le
# dupliquer ici produirait deux paires pre/post par transaction.
#
# AUXI_NO_SNAPSHOT=1 reste honore: le hook lit la meme variable, transmise par
# l'environnement jusqu'a apt-get.

run_snapshot() {
  require_snapshots
  require_root_for_config snapshot "$@"
  local description="${*:-Instantané manuel}"
  local number
  number="$(snapper -c "${SNAPPER_CONFIG}" create \
    --type single --print-number --cleanup-algorithm number \
    --description "${description}" \
    --userdata "auxi=1")"
  say \
    "Instantané ${number} créé: ${description}" \
    "Snapshot ${number} created: ${description}"
}

run_snapshot_list() {
  require_snapshots
  snapper -c "${SNAPPER_CONFIG}" list
}

# Restauration. Sur une disposition plate "@" (la notre), `snapper rollback`
# ne suffit PAS: il joue sur le sous-volume par defaut, alors que /etc/fstab
# monte la racine par CHEMIN (subvol=@). On echange donc les sous-volumes.
#
# L'operation est sure depuis un systeme en cours d'execution: renommer un
# sous-volume monte n'affecte pas le montage courant, et c'est au prochain
# demarrage que subvol=@ resout vers le sous-volume restaure.
# Etat de la protection au demarrage DANS le systeme restaure.
#
# PANNE DU 2026-10-04 (rapportee par aporler): le compteur de demarrages rates
# vit dans /var/lib/auxinux, donc DANS la racine -- il est restaure avec elle.
# Un instantane pris pendant un demarrage (snapper-boot, une seconde apres
# l'allumage) contient un compteur deja incremente: le restaurer faisait croire
# a un bureau en panne au demarrage suivant, la console de secours restaurait a
# son tour le dernier instantane... pris pendant ce demarrage rate, et ainsi de
# suite, sans fin. Remettre le compteur a zero ICI, et non dans le systeme en
# cours (qui est l'ancien), est ce qui casse la boucle.
#
# last-restore: numero restaure, lu par auxinux-rescue pour ne jamais
# restaurer deux fois de suite automatiquement le meme instantane.
reset_boot_state() {
  local root="$1" number="$2"
  local dir="${root}/var/lib/auxinux"
  mkdir -p "${dir}" 2>/dev/null || return 0
  printf '0\n' >"${dir}/boot-failures" 2>/dev/null || true
  printf '%s\n' "${number}" >"${dir}/last-restore" 2>/dev/null || true
}

run_rollback() {
  require_snapshots
  require_root_for_config rollback "$@"

  local assume_yes=0
  local number=""
  local arg
  for arg in "$@"; do
    case "${arg}" in
      --yes|-y) assume_yes=1 ;;
      *) number="${arg}" ;;
    esac
  done

  if [[ -z "${number}" ]]; then
    run_snapshot_list
    say \
      "Choisissez un numéro, puis: sudo auxi rollback NUMÉRO" \
      "Pick a number, then run: sudo auxi rollback NUMBER"
    return 0
  fi

  if [[ ! "${number}" =~ ^[0-9]+$ ]]; then
    say_err "Numéro d'instantané invalide: ${number}" "Invalid snapshot number: ${number}"
    exit 64
  fi

  local root_source root_device
  root_source="$(findmnt -no SOURCE "$(root_mount_ref)" 2>/dev/null || true)"
  # findmnt rend "/dev/sda2[/@]" sur un sous-volume: on retire le suffixe.
  root_device="${root_source%%\[*}"
  if [[ -z "${root_device}" ]]; then
    say_err "Périphérique racine introuvable." "Could not determine root device."
    exit 69
  fi

  mkdir -p "${BTRFS_TOPLEVEL_MNT}"
  if ! mount -o subvolid=5 "${root_device}" "${BTRFS_TOPLEVEL_MNT}"; then
    say_err \
      "Montage de la racine BTRFS impossible: ${root_device}" \
      "Could not mount the BTRFS top level: ${root_device}"
    exit 69
  fi
  trap auxi_rollback_cleanup EXIT

  # @snapshots est un sous-volume de premier niveau (voir mount.conf); on
  # accepte quand meme la disposition imbriquee des installations anciennes.
  local snapshot_src=""
  local candidate
  for candidate in \
    "${BTRFS_TOPLEVEL_MNT}/@snapshots/${number}/snapshot" \
    "${BTRFS_TOPLEVEL_MNT}/@/.snapshots/${number}/snapshot"; do
    if [[ -d "${candidate}" ]]; then
      snapshot_src="${candidate}"
      break
    fi
  done

  if [[ -z "${snapshot_src}" ]]; then
    say_err "Instantané ${number} introuvable." "Snapshot ${number} not found."
    exit 69
  fi

  local stamp saved
  stamp="$(date +%Y%m%d-%H%M%S)"
  saved="@.rollback-${stamp}"

  say \
    "Restauration de l'instantané ${number}." \
    "Restoring snapshot ${number}."
  say \
    "Le système actuel est conservé sous ${saved} et /home n'est pas touché." \
    "The current system is kept as ${saved} and /home is left untouched."
  say \
    "Le changement prend effet au prochain démarrage." \
    "The change takes effect on next boot."

  if [[ "${assume_yes}" -ne 1 ]]; then
    local answer
    say "Confirmer? [o/N]" "Confirm? [y/N]"
    read -r answer
    case "${answer}" in
      o|O|oui|OUI|y|Y|yes|YES) ;;
      *)
        say "Restauration annulée." "Rollback cancelled."
        return 0
        ;;
    esac
  fi

  if ! mv "${BTRFS_TOPLEVEL_MNT}/@" "${BTRFS_TOPLEVEL_MNT}/${saved}"; then
    say_err \
      "Mise de côté du système actuel impossible; rien n'a été modifié." \
      "Could not move the current system aside; nothing was changed."
    exit 69
  fi

  if ! btrfs subvolume snapshot "${snapshot_src}" "${BTRFS_TOPLEVEL_MNT}/@"; then
    # Sans cette remise en place, la machine n'aurait plus AUCUNE racine "@"
    # et ne redemarrerait pas. C'est le seul point vraiment dangereux.
    mv "${BTRFS_TOPLEVEL_MNT}/${saved}" "${BTRFS_TOPLEVEL_MNT}/@" || true
    say_err \
      "Restauration échouée; le système d'origine a été remis en place." \
      "Rollback failed; the original system has been restored."
    exit 69
  fi

  reset_boot_state "${BTRFS_TOPLEVEL_MNT}/@" "${number}"

  say \
    "Restauration prête. Redémarrez pour l'appliquer: sudo reboot" \
    "Rollback ready. Reboot to apply it: sudo reboot"
  say \
    "Ancien système conservé sous le sous-volume ${saved}." \
    "Previous system kept as subvolume ${saved}."
  say \
    "Une fois le redémarrage validé, vous pouvez le supprimer:" \
    "Once the reboot is confirmed working, you can delete it:"
  printf '  sudo auxi rollback-cleanup\n'
}

# Suppression des systemes mis de cote par une restauration.
#
# `auxi rollback` conserve DELIBEREMENT l'ancien systeme sous @.rollback-<date>
# -- c'est le seul recours si la restauration s'avere pire que la panne. Mais
# rien ne les supprimait ensuite: chaque restauration laissait une copie
# complete du systeme sur le disque, jusqu'a saturation. La suppression reste
# manuelle et explicite; elle cesse simplement d'exiger trois commandes
# recopiees a la main.
run_rollback_cleanup() {
  require_root_for_config rollback-cleanup "$@"

  local assume_yes=0 arg
  for arg in "$@"; do
    case "${arg}" in
      --yes|-y) assume_yes=1 ;;
    esac
  done

  local root_source root_device
  root_source="$(findmnt -no SOURCE "$(root_mount_ref)" 2>/dev/null || true)"
  root_device="${root_source%%\[*}"
  if [[ -z "${root_device}" ]]; then
    say_err "Périphérique racine introuvable." "Could not determine root device."
    exit 69
  fi

  mkdir -p "${BTRFS_TOPLEVEL_MNT}"
  if ! mount -o subvolid=5 "${root_device}" "${BTRFS_TOPLEVEL_MNT}"; then
    say_err \
      "Montage de la racine BTRFS impossible: ${root_device}" \
      "Could not mount the BTRFS top level: ${root_device}"
    exit 69
  fi
  trap auxi_rollback_cleanup EXIT

  local saved=()
  local candidate
  for candidate in "${BTRFS_TOPLEVEL_MNT}"/@.rollback-*; do
    [[ -d "${candidate}" ]] || continue
    saved+=("${candidate}")
  done

  if [[ "${#saved[@]}" -eq 0 ]]; then
    say \
      "Aucun système mis de côté par une restauration." \
      "No system set aside by a rollback."
    return 0
  fi

  say \
    "Systèmes conservés par une restauration précédente:" \
    "Systems kept by a previous rollback:"
  for candidate in "${saved[@]}"; do
    printf '  %s\n' "$(basename "${candidate}")"
  done
  say \
    "Ne les supprimez qu'après avoir vérifié que le système restauré démarre." \
    "Only delete these once you have confirmed the restored system boots."

  if [[ "${assume_yes}" -ne 1 ]]; then
    local answer
    say "Supprimer définitivement? [o/N]" "Delete permanently? [y/N]"
    read -r answer
    case "${answer}" in
      o|O|oui|OUI|y|Y|yes|YES) ;;
      *)
        say "Suppression annulée." "Deletion cancelled."
        return 0
        ;;
    esac
  fi

  local failures=0
  for candidate in "${saved[@]}"; do
    if btrfs subvolume delete "${candidate}" >/dev/null 2>&1; then
      say "Supprimé: $(basename "${candidate}")" "Deleted: $(basename "${candidate}")"
    else
      failures=$((failures + 1))
      say_err \
        "Suppression impossible: $(basename "${candidate}")" \
        "Could not delete: $(basename "${candidate}")"
    fi
  done
  [[ "${failures}" -eq 0 ]] || exit 69
}

auxi_rollback_cleanup() {
  umount "${BTRFS_TOPLEVEL_MNT}" >/dev/null 2>&1 || true
  rmdir "${BTRFS_TOPLEVEL_MNT}" >/dev/null 2>&1 || true
}

select_mode() {
  MODE="both"
  if [[ "${1:-}" == "--deb" ]]; then
    MODE="deb"
    shift
  elif [[ "${1:-}" == "--flatpak" ]]; then
    MODE="flatpak"
    shift
  fi
  ARGS=("$@")
}

run_update() {
  select_mode "$@"
  flatpak_opts
  # Droits verifies AVANT la partie Flatpak: sinon, sans sudo, elle tournait
  # puis la commande echouait, et le relais par sudo la referait.
  if [[ "${MODE}" == "both" || "${MODE}" == "deb" ]]; then
    require_root_for_deb update "$@"
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "flatpak" ]]; then
    flatpak update --appstream "${FLATPAK_OPTS[@]}" || true
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "deb" ]]; then
    apt_get update
  fi
}

# Mise a jour du SYSTEME: tous les paquets DEB installes, noyaux compris.
#
# PANNE A L'ORIGINE (2026-10-07): `auxi upgrade` lancait un `apt-get upgrade`
# simple. Quand kernel-auxinuxos passe a une nouvelle version, il depend d'un
# NOUVEAU paquet linux-image-<version>; apt-get upgrade refuse d'installer un
# paquet nouveau, met kernel-auxinuxos de cote (« kept back ») et sort en 0.
# Le noyau ne se serait donc jamais mis a jour, sans aucun message d'erreur.
#
# --with-new-pkgs accepte les paquets nouveaux TIRES PAR des paquets installes
# (le nouveau noyau), mais n'ajoute jamais une application que rien ne demande
# et ne retire jamais rien -- contrairement a full-upgrade.
#
# Le reglage DEB (auxi set deb=...) ne concerne que les APPLICATIONS: il n'est
# pas consulte ici, le systeme doit toujours pouvoir se mettre a jour.
#
# Si cette mise a jour change la VERSION d'AuxiNux OS (nouvelle edition du
# paquet auxinuxos-release), un instantane NOMME est pose d'abord: « Avant
# AuxiNux OS 0.2.1, edition du ... » (exigence d'aporler, 2026-10-09: une montee
# de version de l'OS, depuis le centre ou en ligne de commande, fait TOUJOURS
# un instantane). S'il echoue sur un systeme qui sait en faire, la mise a jour
# est annulee. La paire pre/post du hook dpkg est alors evitee (doublon).
run_osupdate() {
  require_root_for_deb "os upgrade" "$@"
  apt_get update
  local candidate summary snap=0
  candidate="$(release_candidate)"
  if [[ -n "${candidate}" ]]; then
    summary="$(release_summary)"
    say "Nouvelle version: ${summary:-AuxiNux OS ${candidate}}" "New version: ${summary:-AuxiNux OS ${candidate}}"
    if os_snapshot "Avant ${summary:-AuxiNux OS ${candidate}}"; then
      snap=1
    fi
  fi
  if [[ "${snap}" -eq 1 ]]; then
    AUXI_NO_SNAPSHOT=1 apt_get upgrade --with-new-pkgs
    AUXI_NO_SNAPSHOT=1 release_ensure_installed
    AUXI_NO_SNAPSHOT=1 kernel_update_channels
  else
    apt_get upgrade --with-new-pkgs
    release_ensure_installed
    kernel_update_channels
  fi
  if [[ -n "${candidate}" ]]; then
    say "Système à jour: $(os_release_label)" "System up to date: $(os_release_label)"
  fi
}

# Version d'AuxiNux OS proposee par les depots, si elle est plus recente que
# celle installee (ou si le paquet manque: machine d'avant le 2026-10-09).
# Vide sinon. Lit les listes deja chargees.
release_candidate() {
  local policy installed candidate
  policy="$(LC_ALL=C apt_cache policy auxinuxos-release 2>/dev/null || true)"
  candidate="$(sed -n 's/^ *Candidate: *//p' <<<"${policy}" | head -n1)"
  installed="$(sed -n 's/^ *Installed: *//p' <<<"${policy}" | head -n1)"
  [[ -n "${candidate}" && "${candidate}" != "(none)" ]] || return 0
  if [[ -z "${installed}" || "${installed}" == "(none)" ]] \
     || dpkg --compare-versions "${candidate}" gt "${installed}"; then
    printf '%s' "${candidate}"
  fi
}

# « AuxiNux OS 0.2.1, edition du ... » (resume du paquet candidat).
release_summary() {
  LC_ALL=C apt_cache show --no-all-versions auxinuxos-release 2>/dev/null \
    | sed -n 's/^Description: *//p' | head -n1 || true
}

# Nouveautes du paquet candidat, une par ligne.
release_notes() {
  LC_ALL=C apt_cache show --no-all-versions auxinuxos-release 2>/dev/null \
    | awk '/^Description:/ { d = 1; next } d && /^ / { sub(/^ /, ""); if ($0 != ".") print; next } d { exit }' || true
}

# Instantane nomme avant une montee de version de l'OS. Marque « important »:
# le nettoyage automatique de snapper (algorithme number) ne le supprime pas
# avec les points ordinaires. Rend 1 si aucun instantane n'a ete pose sur un
# systeme qui n'en fait pas (la mise a jour continue, avec un avertissement);
# ARRETE tout si l'instantane echoue sur un systeme qui sait en faire.
os_snapshot() {
  local description="$1" number
  if ! snapshots_available; then
    say_err "Attention: pas d'instantané possible sur ce système (racine non BTRFS); la mise à jour continue sans filet." \
            "Warning: snapshots are not possible on this system (non-BTRFS root); updating without a safety net."
    return 1
  fi
  if ! number="$(snapper -c "${SNAPPER_CONFIG}" create --type single --print-number \
        --cleanup-algorithm number --description "${description}" \
        --userdata "auxi=1,important=yes" 2>&1)"; then
    say_err "Instantané impossible: ${number}" "Snapshot failed: ${number}"
    say_err "Mise à jour de la version d'AuxiNux OS annulée: rien n'a été modifié." \
            "AuxiNux OS version upgrade cancelled: nothing was changed."
    exit 69
  fi
  say "Instantané ${number} créé: ${description}" "Snapshot ${number} created: ${description}"
  return 0
}

# auxi os update: une nouvelle version d'AuxiNux OS est-elle disponible?
# N'installe rien. En root, rafraichit d'abord les listes; sinon, lit celles du
# systeme (rafraichies chaque jour par apt-daily, voir 20auxinux-periodic).
run_os_update() {
  if [[ "${EUID}" -eq 0 ]]; then
    apt_get update >/dev/null || true
  fi
  say "Version installée: $(os_release_label)" "Installed version: $(os_release_label)"
  local candidate
  candidate="$(release_candidate)"
  if [[ -z "${candidate}" ]]; then
    say "AuxiNux OS est à jour." "AuxiNux OS is up to date."
    [[ "${EUID}" -eq 0 ]] || say "(Listes du système; sudo auxi os update les rafraîchit d'abord.)" \
                                "(System lists; sudo auxi os update refreshes them first.)"
    return 0
  fi
  local summary
  summary="$(release_summary)"
  say "Nouvelle version disponible: ${summary:-AuxiNux OS ${candidate}}" \
      "New version available: ${summary:-AuxiNux OS ${candidate}}"
  local note
  while IFS= read -r note; do
    [[ -n "${note}" ]] && printf '  - %s\n' "${note}"
  done < <(release_notes)
  say "Pour l'installer (un instantané est créé avant): sudo auxi os upgrade" \
      "To install it (a snapshot is taken first): sudo auxi os upgrade"
  return 0
}

run_os() {
  case "${1:-}" in
    update) shift; run_os_update "$@" ;;
    upgrade) shift; run_osupdate "$@" ;;
    *)
      say_err "Usage: auxi os update | auxi os upgrade" "Usage: auxi os update | auxi os upgrade"
      exit 64
      ;;
  esac
}

# Version d'AuxiNux OS (paquet auxinuxos-release, une edition par ISO publiee).
#
# Une installation faite avant le 2026-10-09 n'a pas ce paquet, et
# `upgrade --with-new-pkgs` n'installe jamais un paquet que rien ne demande:
# sans cette etape, elle ne verrait aucune nouvelle version. Une fois installe,
# chaque nouvelle edition arrive par la mise a jour ordinaire, et tire les
# versions minimales d'auxi, du centre de controle et du noyau.
release_ensure_installed() {
  deb_installed auxinuxos-release && return 0
  apt_cache show --no-all-versions auxinuxos-release >/dev/null 2>&1 || return 0
  say "Installation de la version d'AuxiNux OS (auxinuxos-release)." \
      "Installing the AuxiNux OS release (auxinuxos-release)."
  apt_get install -- auxinuxos-release
}

# « AuxiNux OS 0.2.0, edition du 2026-10-09 » (os-release, champ BUILD_ID).
os_release_label() {
  local file="${AUXI_OS_RELEASE:-/etc/os-release}" name build day n
  name="$(sed -n 's/^PRETTY_NAME="\{0,1\}\([^"]*\)"\{0,1\}$/\1/p' "${file}" 2>/dev/null | head -n1)"
  build="$(sed -n 's/^BUILD_ID="\{0,1\}\([^"]*\)"\{0,1\}$/\1/p' "${file}" 2>/dev/null | head -n1)"
  printf '%s' "${name:-AuxiNux OS}"
  if [[ "${build}" =~ ^([0-9]{4})([0-9]{2})([0-9]{2})(\.([0-9]+))?$ ]]; then
    day="${BASH_REMATCH[1]}-${BASH_REMATCH[2]}-${BASH_REMATCH[3]}"
    n="${BASH_REMATCH[5]:+ (${BASH_REMATCH[5]})}"
    if is_english; then printf ', %s build%s' "${day}" "${n}"
    else printf ', édition du %s%s' "${day}" "${n}"; fi
  fi
  printf '\n'
}

run_upgrade() {
  select_mode "$@"
  flatpak_opts
  local failed=0
  if [[ "${MODE}" == "both" || "${MODE}" == "deb" ]]; then
    require_root_for_deb upgrade "$@"
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "flatpak" ]]; then
    # Un echec Flatpak (Flathub injoignable, runtime retire) ne doit pas priver
    # le systeme de ses correctifs de securite DEB: on continue, et l'echec est
    # rendu a la fin. Avant, `set -e` arretait tout ici.
    if ! flatpak update "${FLATPAK_OPTS[@]}"; then
      failed=1
      say_err \
        "La mise à jour des applications Flatpak a échoué; les paquets système sont mis à jour quand même." \
        "Flatpak application update failed; system packages are updated anyway."
    fi
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "deb" ]]; then
    run_osupdate "$@"
  fi
  return "${failed}"
}

# --- Noyaux AuxiNux ----------------------------------------------------------
#
# Le noyau d'essai n'est PAS une version plus recente du meme paquet: c'est un
# paquet distinct (kernel-auxinuxos-dev -> linux-image-7.2.9-dev-auxinuxos-amd64)
# servi par la suite kernel-dev. Activer la source n'installait donc rien, et
# `auxi install --deb` refuse tout paquet nouveau quand le reglage DEB est
# coupe. D'ou des commandes dediees.
#
# Elles ne consultent PAS le reglage DEB, et ce n'est pas une porte derobee:
# seuls les paquets linux-image-<v> / linux-headers-<v> dont <v> se termine par
# -auxinuxos-amd64 sont acceptes (voir kernel_valid).
#
# Chemins reglables UNIQUEMENT pour les tests (tests/test-auxi-kernel.sh).
GRUB_CFG="${AUXI_GRUB_CFG:-/boot/grub/grub.cfg}"
GRUBENV="${AUXI_GRUBENV:-/boot/grub/grubenv}"
GRUB_DEFAULT_D="${AUXI_GRUB_DEFAULT_D:-/etc/default/grub.d}"
SOURCES_D="${AUXI_SOURCES_D:-/etc/apt/sources.list.d}"
KERNEL_PIN_FILE="50-auxinux-noyau.cfg"
KERNEL_DEV_SOURCE="auxinuxos-kernel-dev.sources"

kernel_valid() {
  [[ "$1" =~ ^[0-9][0-9a-z.+~-]*-auxinuxos-amd64$ ]]
}

kernel_channel() {
  if [[ "$1" == *-dev-* ]]; then printf 'dev'; else printf 'stable'; fi
}

kernel_running() {
  uname -r
}

# Noyaux AuxiNux installes, un par ligne, du plus ancien au plus recent.
kernels_installed() {
  dpkg-query -W -f='${Package}\t${Status}\n' 'linux-image-*' 2>/dev/null \
    | while IFS=$'\t' read -r pkg status; do
        [[ "${status}" == "install ok installed" ]] || continue
        local v="${pkg#linux-image-}"
        kernel_valid "${v}" && printf '%s\n' "${v}"
      done | sort -V || true
}

# Noyaux AuxiNux installables depuis les depots (non installes), du plus
# ancien au plus recent. `apt-cache show` ecarte les noms que dpkg connait
# encore (fichiers de configuration restants) mais qu'aucun depot ne sert.
kernels_available() {
  local installed v
  installed="$(kernels_installed)"
  apt_cache pkgnames linux-image- 2>/dev/null \
    | while read -r pkg; do
        v="${pkg#linux-image-}"
        kernel_valid "${v}" || continue
        grep -Fxq -- "${v}" <<<"${installed}" && continue
        apt_cache show --no-all-versions "linux-image-${v}" >/dev/null 2>&1 || continue
        printf '%s\n' "${v}"
      done | sort -V || true
}

kernel_dev_enabled() {
  [[ -f "${SOURCES_D}/${KERNEL_DEV_SOURCE}" ]]
}

kernel_pinned() {
  [[ -f "${GRUB_DEFAULT_D}/${KERNEL_PIN_FILE}" ]]
}

# Noyau qui demarrera par defaut. Epingle: l'entree enregistree dans grubenv.
# Sinon (GRUB_DEFAULT=0): la premiere entree de grub.cfg, c'est-a-dire le noyau
# que grub-mkconfig a classe le plus recent.
kernel_default() {
  local v=""
  if kernel_pinned && [[ -r "${GRUBENV}" ]]; then
    v="$(sed -n 's/^saved_entry=.*>gnulinux-\(.*\)-advanced-.*$/\1/p' "${GRUBENV}" | head -n1 || true)"
  fi
  if [[ -z "${v}" && -r "${GRUB_CFG}" ]]; then
    v="$(grep -m1 -oE 'vmlinuz-[^[:space:]]+' "${GRUB_CFG}" | sed 's/^vmlinuz-//' || true)"
  fi
  # grub.cfg est en 0600: le centre de controle, qui lit cet etat SANS droits,
  # ne pouvait pas savoir quel noyau demarrerait (constate en VM le
  # 2026-10-07: « Activer » propose sur le noyau deja par defaut). grub-mkconfig
  # classe les noyaux par version (version_sort): le premier est le plus
  # recent installe.
  if [[ -z "${v}" ]]; then
    v="$(kernels_installed | tail -n1)"
  fi
  printf '%s' "${v}"
}

# Identifiant GRUB complet (« sous-menu>entree ») du noyau $1, lu dans grub.cfg.
kernel_grub_id() {
  local v="$1" submenu entry id
  [[ -r "${GRUB_CFG}" ]] || return 1
  submenu="$(grep -oE "'gnulinux-advanced-[^']+'" "${GRUB_CFG}" | head -n1 | tr -d "'" || true)"
  entry=""
  while read -r id; do
    if [[ "${id}" == "gnulinux-${v}-advanced-"* ]]; then
      entry="${id}"
      break
    fi
  done < <(grep -oE "'gnulinux-[^']+-advanced-[^']+'" "${GRUB_CFG}" | tr -d "'" || true)
  [[ -n "${submenu}" && -n "${entry}" ]] || return 1
  printf '%s>%s' "${submenu}" "${entry}"
}

kernel_require_valid() {
  if [[ -z "${1:-}" ]] || ! kernel_valid "$1"; then
    say_err \
      "Version de noyau invalide: ${1:-(vide)}. Exemple: 7.2.5-auxinuxos-amd64 (voir auxi kernel list)." \
      "Invalid kernel version: ${1:-(empty)}. Example: 7.2.5-auxinuxos-amd64 (see auxi kernel list)."
    exit 64
  fi
}

# Here-string et non `kernels_installed | grep -q`: avec pipefail, grep -q qui
# sort a la premiere ligne peut valoir un SIGPIPE a la commande d'amont, et le
# test echouerait alors que le noyau est bien la.
kernel_is_installed() {
  grep -Fxq -- "$1" <<<"$(kernels_installed)"
}

run_kernel_list() {
  local porcelain=0
  [[ "${1:-}" == "--porcelain" ]] && porcelain=1
  local running default installed available v states
  running="$(kernel_running)"
  default="$(kernel_default)"
  installed="$(kernels_installed)"
  available="$(kernels_available)"

  if [[ "${porcelain}" -eq 1 ]]; then
    printf 'actif\t%s\n' "${running}"
    printf 'defaut\t%s\t%s\n' "${default}" "$(kernel_pinned && echo epingle || echo auto)"
    printf 'source-dev\t%s\n' "$(kernel_dev_enabled && echo on || echo off)"
    while read -r v; do
      [[ -n "${v}" ]] || continue
      states="installe"
      [[ "${v}" == "${running}" ]] && states+=",actif"
      [[ "${v}" == "${default}" ]] && states+=",defaut"
      printf 'noyau\t%s\t%s\t%s\n' "${v}" "$(kernel_channel "${v}")" "${states}"
    done <<<"${installed}"
    while read -r v; do
      [[ -n "${v}" ]] || continue
      printf 'noyau\t%s\t%s\tdisponible\n' "${v}" "$(kernel_channel "${v}")"
    done <<<"${available}"
    return 0
  fi

  say "Noyau actif: ${running}" "Running kernel: ${running}"
  if kernel_pinned; then
    say "Démarrage par défaut: ${default:-?} (choisi avec auxi kernel activate)" \
        "Default boot: ${default:-?} (chosen with auxi kernel activate)"
  else
    say "Démarrage par défaut: ${default:-?} (le plus récent)" \
        "Default boot: ${default:-?} (the newest)"
  fi
  if kernel_dev_enabled; then
    say "Noyaux en essai (kernel-dev): activés" "Test kernels (kernel-dev): enabled"
  else
    say "Noyaux en essai (kernel-dev): désactivés (sudo auxi kernel dev on)" \
        "Test kernels (kernel-dev): disabled (sudo auxi kernel dev on)"
  fi
  say "Installés:" "Installed:"
  while read -r v; do
    [[ -n "${v}" ]] || continue
    printf '  %-36s %s%s\n' "${v}" "$(kernel_channel "${v}")" \
      "$([[ "${v}" == "${running}" ]] && echo ' *')"
  done <<<"${installed}"
  if [[ -n "${available}" ]]; then
    say "Disponibles (sudo auxi kernel install VERSION):" "Available (sudo auxi kernel install VERSION):"
    while read -r v; do
      [[ -n "${v}" ]] || continue
      printf '  %-36s %s\n' "${v}" "$(kernel_channel "${v}")"
    done <<<"${available}"
  fi
}

# Paquets a installer pour le noyau $1: l'image, et les en-tetes s'ils existent
# (DKMS: pilotes NVIDIA, VirtualBox...).
kernel_packages() {
  local v="$1"
  printf 'linux-image-%s\n' "${v}"
  if apt_cache show --no-all-versions "linux-headers-${v}" >/dev/null 2>&1; then
    printf 'linux-headers-%s\n' "${v}"
  fi
}

kernel_install_version() {
  local v="$1"
  local pkgs=()
  mapfile -t pkgs < <(kernel_packages "${v}")
  apt_get install -- "${pkgs[@]}"
  if [[ "$(kernel_default)" == "${v}" ]]; then
    say "Noyau ${v} installé: il sera utilisé au prochain démarrage." \
        "Kernel ${v} installed: it will be used on next boot."
  else
    say "Noyau ${v} installé. Pour démarrer dessus: sudo auxi kernel activate ${v}" \
        "Kernel ${v} installed. To boot it: sudo auxi kernel activate ${v}"
  fi
}

run_kernel_install() {
  local v="${1:-}"
  kernel_require_valid "${v}"
  require_root_for_deb kernel install "${v}"
  if kernel_is_installed "${v}"; then
    say "Le noyau ${v} est déjà installé." "Kernel ${v} is already installed."
    return 0
  fi
  if [[ "$(kernel_channel "${v}")" == "dev" ]] && ! kernel_dev_enabled; then
    say_err \
      "Les noyaux en essai sont désactivés. Pour les activer: sudo auxi kernel dev on" \
      "Test kernels are disabled. To enable them: sudo auxi kernel dev on"
    exit 1
  fi
  if ! grep -Fxq -- "${v}" <<<"$(kernels_available)"; then
    say_err \
      "Noyau ${v} introuvable dans les dépôts AuxiNux (voir auxi kernel list)." \
      "Kernel ${v} not found in the AuxiNux repositories (see auxi kernel list)."
    exit 1
  fi
  kernel_install_version "${v}"
}

# Pour chaque canal deja present sur la machine, installe la version la plus
# recente si elle manque. Le canal stable suit aussi kernel-auxinuxos (voir
# run_osupdate); le canal d'essai n'a que ce chemin-ci. Les anciens noyaux sont
# gardes: c'est le recours si le nouveau ne demarre pas.
kernel_update_channels() {
  local installed available channel newest_installed newest_available
  installed="$(kernels_installed)"
  [[ -n "${installed}" ]] || return 0
  available="$(kernels_available)"
  for channel in stable dev; do
    if [[ "${channel}" == "dev" ]] && ! kernel_dev_enabled; then
      continue
    fi
    newest_installed=""
    newest_available=""
    local v
    while read -r v; do
      [[ -n "${v}" && "$(kernel_channel "${v}")" == "${channel}" ]] && newest_installed="${v}"
    done <<<"${installed}"
    [[ -n "${newest_installed}" ]] || continue
    while read -r v; do
      [[ -n "${v}" && "$(kernel_channel "${v}")" == "${channel}" ]] && newest_available="${v}"
    done <<<"${available}"
    [[ -n "${newest_available}" ]] || continue
    if [[ "$(printf '%s\n%s\n' "${newest_installed}" "${newest_available}" | sort -V | tail -n1)" == "${newest_available}" ]]; then
      say "Nouveau noyau $([[ ${channel} == dev ]] && echo "en essai "): ${newest_available}" \
          "New $([[ ${channel} == dev ]] && echo "test ")kernel: ${newest_available}"
      kernel_install_version "${newest_available}"
    fi
  done
}

run_kernel_update() {
  require_root_for_deb kernel update
  apt_get update
  kernel_update_channels
}

# Choix du noyau de demarrage, par l'entree enregistree de GRUB.
#
# GRUB_DEFAULT=0 (overlays/etc/default/grub) demarre toujours la premiere
# entree, donc le noyau le plus recent. Epingler un noyau passe GRUB_DEFAULT a
# « saved » par un fichier de /etc/default/grub.d -- le fichier principal, lui,
# est reecrit par l'installateur -- puis enregistre l'entree voulue.
kernel_set_default() {
  local v="$1" id
  if ! id="$(kernel_grub_id "${v}")"; then
    say_err \
      "Entrée GRUB du noyau ${v} introuvable dans ${GRUB_CFG}; rien n'a été modifié." \
      "GRUB entry for kernel ${v} not found in ${GRUB_CFG}; nothing was changed."
    exit 69
  fi
  install -d -m 0755 "${GRUB_DEFAULT_D}"
  cat >"${GRUB_DEFAULT_D}/${KERNEL_PIN_FILE}" <<'EOF'
# Ecrit par `auxi kernel activate`: demarrer sur le noyau choisi (entree
# enregistree par grub-set-default) plutot que sur le plus recent.
# Pour revenir au plus recent: sudo auxi kernel activate latest
GRUB_DEFAULT=saved
EOF
  update-grub
  # Relu APRES update-grub: l'identifiant ne change pas, mais c'est le fichier
  # regenere qui sera lu au demarrage.
  id="$(kernel_grub_id "${v}")" || {
    rm -f "${GRUB_DEFAULT_D}/${KERNEL_PIN_FILE}"
    update-grub
    say_err "Entrée GRUB du noyau ${v} disparue après update-grub." \
            "GRUB entry for kernel ${v} vanished after update-grub."
    exit 69
  }
  grub-set-default "${id}"
}

kernel_unpin() {
  kernel_pinned || return 0
  rm -f "${GRUB_DEFAULT_D}/${KERNEL_PIN_FILE}"
  update-grub
  grub-editenv "${GRUBENV}" unset saved_entry 2>/dev/null || true
}

run_kernel_activate() {
  local v="${1:-}"
  if [[ "${v}" == "latest" ]]; then
    require_root_for_deb kernel activate latest
    kernel_unpin
    say "Le noyau le plus récent sera utilisé au prochain démarrage." \
        "The newest kernel will be used on next boot."
    return 0
  fi
  kernel_require_valid "${v}"
  require_root_for_deb kernel activate "${v}"
  if ! kernel_is_installed "${v}"; then
    say_err "Le noyau ${v} n'est pas installé." "Kernel ${v} is not installed."
    exit 1
  fi
  kernel_set_default "${v}"
  say "Le noyau ${v} sera utilisé au prochain démarrage." \
      "Kernel ${v} will be used on next boot."
}

run_kernel_remove() {
  local v="${1:-}"
  kernel_require_valid "${v}"
  require_root_for_deb kernel remove "${v}"
  if ! kernel_is_installed "${v}"; then
    say_err "Le noyau ${v} n'est pas installé." "Kernel ${v} is not installed."
    exit 1
  fi
  if [[ "${v}" == "$(kernel_running)" ]]; then
    say_err \
      "Le noyau ${v} est celui qui tourne: redémarrez sur un autre noyau avant de le désinstaller." \
      "Kernel ${v} is the running kernel: reboot into another kernel before removing it."
    exit 1
  fi
  local k stables=0
  while read -r k; do
    [[ -n "${k}" && "$(kernel_channel "${k}")" == "stable" ]] && stables=$((stables + 1))
  done < <(kernels_installed)
  if [[ "$(kernel_channel "${v}")" == "stable" && "${stables}" -le 1 ]]; then
    say_err \
      "Le noyau ${v} est le dernier noyau stable installé: il est gardé." \
      "Kernel ${v} is the last installed stable kernel: it is kept."
    exit 1
  fi

  local pkgs=("linux-image-${v}")
  if deb_installed "linux-headers-${v}"; then
    pkgs+=("linux-headers-${v}")
  fi

  # Simulation d'abord: apt retire aussi ce qui DEPEND du noyau. Si c'est
  # kernel-auxinuxos (le noyau que suit la mise a jour du systeme), on refuse:
  # sans lui, plus aucun noyau stable n'arriverait. kernel-auxinuxos-dev peut
  # partir avec son noyau d'essai.
  local sim pkg blocked=()
  sim="$("$(apt_real apt-get)" -s purge -- "${pkgs[@]}" 2>&1)" || {
    printf '%s\n' "${sim}" >&2
    exit 1
  }
  while read -r pkg; do
    case "${pkg}" in
      linux-image-*) kernel_valid "${pkg#linux-image-}" || blocked+=("${pkg}") ;;
      linux-headers-*) kernel_valid "${pkg#linux-headers-}" || blocked+=("${pkg}") ;;
      kernel-auxinuxos-dev) ;;
      *) blocked+=("${pkg}") ;;
    esac
  done < <(sed -n 's/^Purg \([^ ]*\).*/\1/p' <<<"${sim}")
  if [[ "${#blocked[@]}" -gt 0 ]]; then
    say_err \
      "Désinstaller ${v} retirerait aussi: ${blocked[*]}. C'est le noyau que suit la mise à jour du système: il est gardé." \
      "Removing ${v} would also remove: ${blocked[*]}. The system update follows this kernel: it is kept."
    exit 1
  fi

  local was_default=0
  kernel_pinned && [[ "$(kernel_default)" == "${v}" ]] && was_default=1
  apt_get purge -- "${pkgs[@]}"
  if [[ "${was_default}" -eq 1 ]]; then
    kernel_unpin
    say "Le noyau le plus récent sera utilisé au prochain démarrage." \
        "The newest kernel will be used on next boot."
  fi
  say "Noyau ${v} désinstallé." "Kernel ${v} removed."
}

run_kernel_dev() {
  local base="${SOURCES_D}/${KERNEL_DEV_SOURCE}"
  case "${1:-}" in
    on)
      require_root_for_deb kernel dev on
      if [[ ! -f "${base}" ]]; then
        if [[ ! -f "${base}.disabled" ]]; then
          say_err "Source kernel-dev introuvable: ${base}.disabled" \
                  "kernel-dev source not found: ${base}.disabled"
          exit 69
        fi
        mv -f "${base}.disabled" "${base}"
      fi
      apt_get update
      say "Noyaux en essai activés. Pour en installer un: auxi kernel list, puis sudo auxi kernel install VERSION" \
          "Test kernels enabled. To install one: auxi kernel list, then sudo auxi kernel install VERSION"
      ;;
    off)
      require_root_for_deb kernel dev off
      if [[ -f "${base}" ]]; then
        mv -f "${base}" "${base}.disabled"
      fi
      apt_get update
      say "Noyaux en essai désactivés." "Test kernels disabled."
      if grep -q -- '-dev-' <<<"$(kernels_installed)"; then
        say "Les noyaux en essai déjà installés sont gardés; ils ne recevront plus de mise à jour." \
            "Test kernels already installed are kept; they will no longer be updated."
      fi
      ;;
    *)
      say_err "Usage: auxi kernel dev on|off" "Usage: auxi kernel dev on|off"
      exit 64
      ;;
  esac
}

run_kernel() {
  local sub="${1:-list}"
  [[ $# -gt 0 ]] && shift
  case "${sub}" in
    list) run_kernel_list "$@" ;;
    install) run_kernel_install "$@" ;;
    update) run_kernel_update ;;
    activate) run_kernel_activate "$@" ;;
    remove|uninstall) run_kernel_remove "$@" ;;
    dev) run_kernel_dev "$@" ;;
    *)
      say_err "Sous-commande inconnue: kernel ${sub}" "Unknown subcommand: kernel ${sub}"
      say_err "Usage: auxi kernel list|install|update|activate|remove|dev" \
              "Usage: auxi kernel list|install|update|activate|remove|dev"
      exit 64
      ;;
  esac
}

run_search() {
  select_mode "$@"
  local term="${ARGS[0]:-}"
  if [[ -z "${term}" ]]; then
    say_err "Recherche manquante." "Missing search term."
    exit 64
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "flatpak" ]]; then
    echo "== Flatpak =="
    flatpak search -- "${term}" || true
  fi
  # Sans --deb, les paquets DEB ne sont proposes que si leur installation est
  # activee: ailleurs, on les listerait sans pouvoir les installer.
  if [[ "${MODE}" == "deb" ]] || { [[ "${MODE}" == "both" ]] && deb_apps_enabled; }; then
    echo "== DEB =="
    apt_cache search -- "${term}" || true
  fi
}

run_install() {
  select_mode "$@"
  local item="${ARGS[0]:-}"
  if [[ -z "${item}" ]]; then
    say_err \
      "Élément à installer manquant." \
      "Missing package or application to install."
    exit 64
  fi
  flatpak_opts
  # Avec --flatpak ou --deb, PLUSIEURS elements sont acceptes: l'assistant de
  # premier demarrage installe toute une selection en une seule transaction
  # (une seule autorisation, un seul instantane). --or-update: une
  # application deja presente est mise a jour au lieu de faire echouer le
  # lot -- c'est le cas quand on relance l'assistant.
  if [[ "${MODE}" == "flatpak" ]]; then
    flatpak install "${FLATPAK_OPTS[@]}" --or-update flathub -- "${ARGS[@]}"
  elif [[ "${MODE}" == "deb" ]]; then
    # --deb explicite: un paquet NOUVEAU est refuse tant que l'installation DEB
    # n'est pas activee. Un paquet deja installe passe: c'est ainsi que le
    # centre met a jour une application DEB (AuxiNux Office), et pkexec ne
    # transmet aucune variable d'environnement. L'assistant de premier
    # demarrage, qui installe ses propres paquets (Brave, depuis son depot),
    # passe AUXI_DEB_SYSTEME=1.
    if ! deb_apps_enabled && [[ "${AUXI_DEB_SYSTEME:-0}" != "1" ]]; then
      local pkg
      for pkg in "${ARGS[@]}"; do
        if ! deb_installed "${pkg}"; then
          say_err "Paquet DEB non installé: ${pkg}" "DEB package not installed: ${pkg}"
          deb_disabled_hint
          exit 1
        fi
      done
    fi
    require_root_for_deb install "$@"
    apt_get install -- "${ARGS[@]}"
  else
    # Flatpak TOUJOURS d'abord; le DEB seulement si aucun Flatpak ne
    # correspond, et seulement si l'installation DEB est activee.
    local id
    for item in "${ARGS[@]}"; do
      if id="$(resolve_flatpak "${item}")"; then
        [[ "${id}" != "${item}" ]] && say \
          "${item}: application Flatpak ${id}" \
          "${item}: Flatpak application ${id}"
        flatpak install "${FLATPAK_OPTS[@]}" flathub -- "${id}"
      elif deb_apps_enabled; then
        say \
          "Aucun Flatpak trouvé pour ${item}; installation DEB." \
          "No Flatpak found for ${item}; using DEB installation."
        require_root_for_deb install "${item}"
        apt_get install -- "${item}"
      else
        say_err \
          "Aucune application Flatpak nommée ${item}." \
          "No Flatpak application named ${item}."
        show_flatpak_suggestions "${item}"
        deb_disabled_hint
        exit 1
      fi
    done
  fi
}

run_uninstall() {
  select_mode "$@"
  local item="${ARGS[0]:-}"
  if [[ -z "${item}" ]]; then
    say_err \
      "Élément à désinstaller manquant." \
      "Missing package or application to uninstall."
    exit 64
  fi
  flatpak_opts
  if [[ "${MODE}" == "flatpak" ]]; then
    flatpak uninstall "${FLATPAK_OPTS[@]}" -- "${item}"
  elif [[ "${MODE}" == "deb" ]]; then
    require_root_for_deb uninstall "$@"
    apt_get remove -- "${item}"
  else
    require_root_for_deb uninstall "$@"
    # Une desinstallation Flatpak ne modifie pas l'etat systeme capture par
    # "@": aucun instantane n'est pose tant qu'on ne retombe pas sur DEB, ce
    # dont le hook dpkg se charge desormais.
    if ! flatpak uninstall "${FLATPAK_OPTS[@]}" -- "${item}"; then
      apt_get remove -- "${item}"
    fi
  fi
}

# Options globales, AVANT la commande. Elles ne sont pas cherchees dans le
# reste de la ligne: `auxi rollback N --yes` a deja son propre --yes, qui
# confirme une restauration -- un sens different qu'il ne faut pas capter ici.
ASSUME_YES=0
PROGRESS=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --yes|-y) ASSUME_YES=1; shift ;;
    --progress) PROGRESS=1; shift ;;
    *) break ;;
  esac
done
if [[ "${ASSUME_YES}" -eq 1 ]]; then
  export DEBIAN_FRONTEND=noninteractive
fi

case "${1:-}" in
  update)
    shift; run_update "$@"
    ;;
  upgrade)
    shift; run_upgrade "$@"
    ;;
  os)
    shift; run_os "$@"
    ;;
  osupdate)
    # Ancien nom de « auxi os upgrade », garde pour les scripts existants.
    shift; run_osupdate "$@"
    ;;
  kernel)
    shift; run_kernel "$@"
    ;;
  search)
    shift; run_search "$@"
    ;;
  install)
    shift; run_install "$@"
    ;;
  uninstall|remove)
    shift; run_uninstall "$@"
    ;;
  purge)
    shift
    require_root_for_deb purge "$@"
    apt_get purge -- "$@"
    ;;
  clean)
    require_root_for_deb clean
    apt_get clean
    ;;
  autoclean)
    require_root_for_deb autoclean
    apt_get autoclean
    ;;
  snapshot)
    shift; run_snapshot "$@"
    ;;
  snapshots)
    shift; run_snapshot_list
    ;;
  rollback)
    shift; run_rollback "$@"
    ;;
  rollback-cleanup)
    shift; run_rollback_cleanup "$@"
    ;;
  set)
    shift
    case "${1:-}" in
      apt=*) set_apt "${1#apt=}" ;;
      deb=*) set_deb_apps "${1#deb=}" ;;
      *) say_err "Usage: auxi set apt=true|false | deb=true|false" "Usage: auxi set apt=true|false | deb=true|false"; exit 64 ;;
    esac
    ;;
  status)
    os_release_label
    if apt_enabled; then
      say "APT direct: actif" "Direct APT: enabled"
    else
      say "APT direct: masqué, utilisez auxi" "Direct APT: hidden, use auxi"
    fi
    if deb_apps_enabled; then
      say "Installation DEB: activée (Flatpak reste prioritaire)" "DEB installation: enabled (Flatpak stays first)"
    else
      say "Installation DEB: désactivée, applications Flatpak seulement" "DEB installation: disabled, Flatpak applications only"
    fi
    if snapshots_available; then
      say "Rollback système: actif (BTRFS + snapper)" \
          "System rollback: enabled (BTRFS + snapper)"
      snapper -c "${SNAPPER_CONFIG}" list 2>/dev/null | tail -n 5 || true
    else
      say "Rollback système: indisponible sur ce système" \
          "System rollback: unavailable on this system"
    fi
    ;;
  -h|--help|help|"")
    usage
    ;;
  *)
    say_err "Commande inconnue: $1" "Unknown command: $1"
    usage >&2
    exit 64
    ;;
esac
