#!/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"

is_english() {
  local locale_chain="${LC_ALL:-}|${LC_MESSAGES:-}|${LANGUAGE:-}|${LANG:-}"
  [[ "${locale_chain}" =~ (^|[|:])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 osupdate
  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.

The system (osupdate: every installed DEB package, kernels included) and the
AuxiNux kernels (kernel) never depend 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 osupdate
  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.

Le système (osupdate: tous les paquets DEB installés, noyaux compris) et les
noyaux AuxiNux (kernel) ne dépendent jamais 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
}

require_root_for_config() {
  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() {
  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
  if [[ "${MODE}" == "both" || "${MODE}" == "flatpak" ]]; then
    flatpak update --appstream "${FLATPAK_OPTS[@]}" || true
  fi
  if [[ "${MODE}" == "both" || "${MODE}" == "deb" ]]; then
    require_root_for_deb update "$@"
    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.
run_osupdate() {
  require_root_for_deb osupdate "$@"
  apt_get update
  apt_get upgrade --with-new-pkgs
  kernel_update_channels
}

run_upgrade() {
  select_mode "$@"
  flatpak_opts
  local failed=0
  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 "$@"
    ;;
  osupdate)
    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)
    echo "AuxiNux OS 0.2.0"
    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
