apply.sh

#!/bin/bash
# BC-250 tweaks — idempotent apply script
set -euo pipefail

REPO_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
CONFIGS="$REPO_DIR/configs"

# Detect target user (first non-root user with UID >= 1000)
TARGET_USER="${SUDO_USER:-${USER:-bazzite}}"
if [ "$TARGET_USER" = "root" ]; then
    TARGET_USER=$(getent passwd | awk -F: '$3>=1000 && $3<65000 {print $1; exit}')
fi
TARGET_HOME=$(getent passwd "$TARGET_USER" | cut -d: -f6)

log()  { echo "[+] $*"; }
skip() { echo "[=] $* (déjà OK)"; }
warn() { echo "[!] $*"; }

need_root() {
    if [ "$(id -u)" -ne 0 ]; then
        warn "Ce script doit être lancé en root (sudo) pour appliquer les tweaks système."
        exit 1
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 0. Détection de l'OS — applique la BONNE méthode selon la distro
# ══════════════════════════════════════════════════════════════════════════════
# Le BC-250 tourne sur plusieurs OS (doc communautaire : Bazzite, SteamOS,
# CachyOS/Arch, Fedora, Debian…). Chaque distro diffère sur : ① l'immutabilité
# (ostree ⇒ pas d'install de paquet classique, kargs via rpm-ostree), ② le
# gestionnaire de paquets, ③ la façon de poser des kargs kernel. On détecte tout
# ça une fois et les fonctions apply_* s'adaptent.
OS_ID="unknown"; OS_LIKE=""; OS_NAME="unknown"
IS_OSTREE=0; PKG_MGR="unknown"; KARG_METHOD="manual"

detect_os() {
    if [ -r /etc/os-release ]; then
        # shellcheck disable=SC1091
        . /etc/os-release
        OS_ID="${ID:-unknown}"
        OS_LIKE="${ID_LIKE:-}"
        OS_NAME="${PRETTY_NAME:-${NAME:-unknown}}"
    fi

    # Système immuable basé sur ostree (Bazzite, SteamOS, Silverblue/Kinoite…) :
    # le / est en lecture seule, on ne peut pas `dnf install` sans layering+reboot.
    if command -v rpm-ostree >/dev/null 2>&1 && { [ -d /run/ostree ] || [ -d /ostree ]; }; then
        IS_OSTREE=1
    fi

    # Gestionnaire de paquets
    if [ "$IS_OSTREE" -eq 1 ]; then
        PKG_MGR="rpm-ostree"
    elif command -v dnf >/dev/null 2>&1; then
        PKG_MGR="dnf"
    elif command -v pacman >/dev/null 2>&1; then
        PKG_MGR="pacman"
    elif command -v apt-get >/dev/null 2>&1; then
        PKG_MGR="apt"
    fi

    # Méthode pour poser des arguments kernel (kargs) :
    #  - ostree         → rpm-ostree kargs (persistant, atomique)
    #  - grubby         → Fedora/RHEL mutables (gère aussi les entrées BLS)
    #  - limine         → CachyOS Limine : /etc/default/limine + limine-mkinitcpio
    #  - sdboot-manage  → CachyOS systemd-boot : LINUX_OPTIONS + sdboot-manage gen
    #  - sdboot-entries → systemd-boot sans outil : édition des options dans
    #                     loader/entries/*.conf (backup .bc250.bak, effet immédiat ;
    #                     ⚠ un hook de MAJ kernel peut régénérer les entrées)
    #  - grub           → /etc/default/grub + (update-grub|grub*-mkconfig)
    #  - refind         → /boot/refind_linux.conf (1re ligne = options par défaut)
    #  - manual         → bootloader non identifié : on affiche les kargs à ajouter
    #                     à la main plutôt que risquer un boot cassé.
    # Les chemins vérifiant l'install RÉELLE dans l'ESP (limine/systemd-boot)
    # passent avant grub, dont la détection ne repose que sur la présence de
    # /etc/default/grub (souvent un reste de paquet non utilisé).
    if [ "$IS_OSTREE" -eq 1 ]; then
        KARG_METHOD="rpm-ostree"
    elif command -v grubby >/dev/null 2>&1; then
        KARG_METHOD="grubby"
    elif [ -f "$LIMINE_DEFAULT" ] && command -v limine-mkinitcpio >/dev/null 2>&1; then
        KARG_METHOD="limine"
    elif command -v sdboot-manage >/dev/null 2>&1 && [ -f "$SDBOOT_CONF" ]; then
        KARG_METHOD="sdboot-manage"
    elif _sdboot_installed && [ -n "$(_sdboot_entries)" ]; then
        KARG_METHOD="sdboot-entries"
    elif [ -f /etc/default/grub ] && \
         { command -v update-grub >/dev/null 2>&1 || \
           command -v grub-mkconfig >/dev/null 2>&1 || \
           command -v grub2-mkconfig >/dev/null 2>&1; }; then
        KARG_METHOD="grub"
    elif [ -f "$REFIND_CONF" ]; then
        KARG_METHOD="refind"
    else
        KARG_METHOD="manual"
    fi
}

# Chemins surchargeables (tests sandbox : pointer vers une arborescence factice)
SDBOOT_CONF="${SDBOOT_CONF:-/etc/sdboot-manage.conf}"
LIMINE_DEFAULT="${LIMINE_DEFAULT:-/etc/default/limine}"
REFIND_CONF="${REFIND_CONF:-/boot/refind_linux.conf}"
SDBOOT_ENTRY_DIRS="${SDBOOT_ENTRY_DIRS:-/boot/loader/entries /efi/loader/entries /boot/efi/loader/entries}"

_sdboot_installed() {
    if command -v bootctl >/dev/null 2>&1; then
        bootctl is-installed >/dev/null 2>&1 && return 0
    fi
    local d
    for d in $SDBOOT_ENTRY_DIRS; do [ -d "$d" ] && return 0; done
    return 1
}

# Entrées systemd-boot éditables (on ne touche pas aux entrées fallback)
_sdboot_entries() {
    local d f
    for d in $SDBOOT_ENTRY_DIRS; do
        [ -d "$d" ] || continue
        for f in "$d"/*.conf; do
            [ -f "$f" ] || continue
            case "$(basename "$f")" in *fallback*) continue ;; esac
            echo "$f"
        done
        return  # un seul répertoire d'entrées actif
    done
}

# Backup one-shot avant première modification d'un fichier bootloader
_boot_backup() {
    local f="$1"
    [ -f "$f" ] && [ ! -f "$f.bc250.bak" ] && cp -p "$f" "$f.bc250.bak" || true
}

# ── kernel args : helpers indépendants du bootloader ───────────────────────────
_grub_cfg_path() {
    local p
    for p in /boot/grub2/grub.cfg /boot/grub/grub.cfg \
             /boot/efi/EFI/*/grub.cfg /efi/EFI/*/grub.cfg; do
        [ -f "$p" ] && { echo "$p"; return; }
    done
    echo /boot/grub/grub.cfg
}

_grub_regen() {
    if command -v update-grub >/dev/null 2>&1; then
        update-grub
    elif command -v grub2-mkconfig >/dev/null 2>&1; then
        grub2-mkconfig -o "$(_grub_cfg_path)"
    elif command -v grub-mkconfig >/dev/null 2>&1; then
        grub-mkconfig -o "$(_grub_cfg_path)"
    fi
}

# ── helpers génériques : VAR="a b c" dans un fichier shell ─────────────────────
# Ajoute les args manquants dans la valeur entre guillemets de <var> dans <file>
# (crée la ligne si absente), en préservant le reste du fichier. Sert à GRUB
# (GRUB_CMDLINE_LINUX_DEFAULT) et à sdboot-manage (LINUX_OPTIONS).
_shvar_append_args() {
    local f="$1" var="$2"; shift 2
    [ -f "$f" ] || { warn "$f absent — kargs non posés"; return 1; }
    _boot_backup "$f"
    grep -q "^${var}=" "$f" || echo "${var}=\"\"" >> "$f"
    # awk : réécrit la ligne en ajoutant les args absents, en préservant les guillemets
    local tmp; tmp=$(mktemp)
    awk -v add="$*" -v var="$var" '
        index($0, var"=") == 1 {
            line=$0
            q=index(line,"\""); q2=(q ? index(substr(line,q+1),"\"")+q : 0)
            inner=(q && q2>q ? substr(line,q+1,q2-q-1) : "")
            n=split(inner, cur, /[ \t]+/)
            # set existant
            for (i=1;i<=n;i++) if (cur[i]!="") seen[cur[i]]=1
            out=inner
            m=split(add, a, /[ \t]+/)
            for (i=1;i<=m;i++) if (a[i]!="" && !(a[i] in seen)) { out=(out=="" ? a[i] : out" "a[i]); seen[a[i]]=1 }
            print var"=\"" out "\""
            next
        }
        { print }
    ' "$f" > "$tmp" && install -m 644 "$tmp" "$f"
    rm -f "$tmp"
}

_shvar_remove_arg() {
    local f="$1" var="$2" arg="$3"
    [ -f "$f" ] || return 0
    _boot_backup "$f"
    local tmp; tmp=$(mktemp)
    awk -v rm="$arg" -v var="$var" '
        index($0, var"=") == 1 {
            line=$0
            q=index(line,"\""); q2=(q ? index(substr(line,q+1),"\"")+q : 0)
            inner=(q && q2>q ? substr(line,q+1,q2-q-1) : "")
            n=split(inner, cur, /[ \t]+/); out=""
            for (i=1;i<=n;i++) if (cur[i]!="" && cur[i]!=rm) out=(out=="" ? cur[i] : out" "cur[i])
            print var"=\"" out "\""
            next
        }
        { print }
    ' "$f" > "$tmp" && install -m 644 "$tmp" "$f"
    rm -f "$tmp"
}

_grub_append_args() { _shvar_append_args /etc/default/grub GRUB_CMDLINE_LINUX_DEFAULT "$@"; }
_grub_remove_arg()  { _shvar_remove_arg  /etc/default/grub GRUB_CMDLINE_LINUX_DEFAULT "$1"; }

# ── systemd-boot sans sdboot-manage : édition directe des entrées ──────────────
# Ajoute les args manquants sur la (1re) ligne `options` de chaque entrée non-
# fallback. Effet immédiat (systemd-boot relit les entrées à chaque boot).
_sdboot_entries_append_args() {
    local f tmp changed=1
    for f in $(_sdboot_entries); do
        _boot_backup "$f"
        tmp=$(mktemp)
        awk -v add="$*" '
            /^options([ \t]|$)/ && !done {
                done=1
                inner=$0; sub(/^options[ \t]*/, "", inner)
                n=split(inner, cur, /[ \t]+/)
                for (i=1;i<=n;i++) if (cur[i]!="") seen[cur[i]]=1
                out=inner
                m=split(add, a, /[ \t]+/)
                for (i=1;i<=m;i++) if (a[i]!="" && !(a[i] in seen)) { out=(out=="" ? a[i] : out" "a[i]); seen[a[i]]=1 }
                print "options " out
                next
            }
            { print }
            END { if (!done) print "options " add }
        ' "$f" > "$tmp" && install -m 644 "$tmp" "$f" && changed=0
        rm -f "$tmp"
    done
    return $changed
}

_sdboot_entries_remove_arg() {
    local f tmp arg="$1"
    for f in $(_sdboot_entries); do
        _boot_backup "$f"
        tmp=$(mktemp)
        awk -v rm="$arg" '
            /^options([ \t]|$)/ {
                inner=$0; sub(/^options[ \t]*/, "", inner)
                n=split(inner, cur, /[ \t]+/); out=""
                for (i=1;i<=n;i++) if (cur[i]!="" && cur[i]!=rm) out=(out=="" ? cur[i] : out" "cur[i])
                print "options " out
                next
            }
            { print }
        ' "$f" > "$tmp" && install -m 644 "$tmp" "$f"
        rm -f "$tmp"
    done
}

# ── Limine (CachyOS) : /etc/default/limine + limine-mkinitcpio ─────────────────
# On n'édite PAS les lignes KERNEL_CMDLINE existantes de l'utilisateur : on gère
# NOTRE ligne additive `KERNEL_CMDLINE[default]+=" …"` repérée par un marqueur,
# fusionnée/réécrite à chaque run (idempotent).
_LIMINE_MARK="# bc250-tweaks kargs (géré par apply.sh)"

_limine_our_args() {
    [ -f "$LIMINE_DEFAULT" ] || return 0
    grep -A1 -F "$_LIMINE_MARK" "$LIMINE_DEFAULT" 2>/dev/null \
        | sed -n 's/^KERNEL_CMDLINE\[default\]+=" \(.*\)"$/\1/p'
}

_limine_write_line() {
    # $* = liste FINALE d'args de notre ligne (vide = retirer la ligne)
    local f="$LIMINE_DEFAULT" tmp; tmp=$(mktemp)
    _boot_backup "$f"
    grep -v -F "$_LIMINE_MARK" "$f" 2>/dev/null \
        | grep -v '^KERNEL_CMDLINE\[default\]+=" .*"[ \t]*$' > "$tmp" || true
    if [ -n "$*" ]; then
        printf '%s\nKERNEL_CMDLINE[default]+=" %s"\n' "$_LIMINE_MARK" "$*" >> "$tmp"
    fi
    install -m 644 "$tmp" "$f"
    rm -f "$tmp"
}

_limine_append_args() {
    [ -f "$LIMINE_DEFAULT" ] || { warn "$LIMINE_DEFAULT absent"; return 1; }
    local cur out a
    cur=$(_limine_our_args)
    out="$cur"
    for a in "$@"; do
        case " $out " in *" $a "*) ;; *) out="${out:+$out }$a" ;; esac
    done
    [ "$out" = "$cur" ] && return 0
    _limine_write_line $out
    limine-mkinitcpio >/dev/null 2>&1 || warn "limine-mkinitcpio a échoué — relance-le à la main"
}

_limine_remove_arg() {
    local arg="$1" cur out a
    cur=$(_limine_our_args)
    out=""
    for a in $cur; do [ "$a" = "$arg" ] || out="${out:+$out }$a"; done
    if [ "$out" != "$cur" ]; then
        _limine_write_line $out
        limine-mkinitcpio >/dev/null 2>&1 || true
    elif [ -f "$LIMINE_DEFAULT" ] && grep -q -- "$arg" "$LIMINE_DEFAULT" 2>/dev/null; then
        warn "$arg présent dans $LIMINE_DEFAULT hors de notre ligne — retire-le à la main"
    fi
}

# ── rEFInd : 1re ligne de refind_linux.conf = options de boot par défaut ───────
_refind_append_args() {
    local f="$REFIND_CONF"
    [ -f "$f" ] || { warn "$f absent"; return 1; }
    _boot_backup "$f"
    local tmp; tmp=$(mktemp)
    # "label"  "options" → ajoute les args absents dans le 2e champ quoté.
    # Parsing par index() (portable mawk/busybox — pas de match() à 3 args gawk).
    awk -v add="$*" '
        NR==1 && /^[ \t]*"/ {
            line=$0
            q1=index(line,"\"")                                  # ouvre label
            r=substr(line,q1+1); q2=index(r,"\"")                # ferme label
            r2=substr(r,q2+1);   q3=index(r2,"\"")               # ouvre options
            r3=substr(r2,q3+1);  q4=index(r3,"\"")               # ferme options
            if (q1 && q2 && q3 && q4) {
                head=substr(line,1,q1+q2+q3)                     # jusqu à la " ouvrante des options incluse
                inner=substr(r3,1,q4-1)
                n=split(inner, cur, /[ \t]+/)
                for (i=1;i<=n;i++) if (cur[i]!="") seen[cur[i]]=1
                out=inner
                m=split(add, a, /[ \t]+/)
                for (i=1;i<=m;i++) if (a[i]!="" && !(a[i] in seen)) { out=(out=="" ? a[i] : out" "a[i]); seen[a[i]]=1 }
                print head out "\""
                next
            }
        }
        { print }
    ' "$f" > "$tmp" && install -m 644 "$tmp" "$f"
    rm -f "$tmp"
}

_refind_remove_arg() {
    local f="$REFIND_CONF" arg="$1"
    [ -f "$f" ] || return 0
    _boot_backup "$f"
    local tmp; tmp=$(mktemp)
    awk -v rm="$arg" '
        NR==1 && /^[ \t]*"/ {
            line=$0
            q1=index(line,"\"")
            r=substr(line,q1+1); q2=index(r,"\"")
            r2=substr(r,q2+1);   q3=index(r2,"\"")
            r3=substr(r2,q3+1);  q4=index(r3,"\"")
            if (q1 && q2 && q3 && q4) {
                head=substr(line,1,q1+q2+q3)
                inner=substr(r3,1,q4-1)
                n=split(inner, cur, /[ \t]+/); out=""
                for (i=1;i<=n;i++) if (cur[i]!="" && cur[i]!=rm) out=(out=="" ? cur[i] : out" "cur[i])
                print head out "\""
                next
            }
        }
        { print }
    ' "$f" > "$tmp" && install -m 644 "$tmp" "$f"
    rm -f "$tmp"
}

# Ajoute une liste de kargs (déjà filtrés = seulement les manquants). Renvoie 0
# si posés, 1 si méthode manuelle (l'appelant affiche alors les instructions).
karg_add_all() {
    case "$KARG_METHOD" in
        rpm-ostree)
            local a=(); local k
            for k in "$@"; do a+=("--append=$k"); done
            rpm-ostree kargs "${a[@]}"
            ;;
        grubby)
            grubby --update-kernel=ALL --args="$*"
            ;;
        grub)
            _grub_append_args "$@" && _grub_regen
            ;;
        limine)
            _limine_append_args "$@"
            ;;
        sdboot-manage)
            _shvar_append_args "$SDBOOT_CONF" LINUX_OPTIONS "$@" && sdboot-manage gen
            ;;
        sdboot-entries)
            _sdboot_entries_append_args "$@"
            ;;
        refind)
            _refind_append_args "$@"
            ;;
        *)
            return 1
            ;;
    esac
}

karg_remove() {
    case "$KARG_METHOD" in
        rpm-ostree)     rpm-ostree kargs --delete-if-present="$1" ;;
        grubby)         grubby --update-kernel=ALL --remove-args="$1" ;;
        grub)           _grub_remove_arg "$1" && _grub_regen ;;
        limine)         _limine_remove_arg "$1" ;;
        sdboot-manage)  _shvar_remove_arg "$SDBOOT_CONF" LINUX_OPTIONS "$1" && sdboot-manage gen ;;
        sdboot-entries) _sdboot_entries_remove_arg "$1" ;;
        refind)         _refind_remove_arg "$1" ;;
    esac
}

# ── paquets : installe un paquet natif (hors ostree) ───────────────────────────
pkg_install() {
    # $@ = noms de paquet (mêmes noms sur dnf/pacman/apt pour gamemode)
    case "$PKG_MGR" in
        dnf)    dnf install -y "$@" ;;
        pacman) pacman -S --needed --noconfirm "$@" ;;
        apt)    apt-get update -qq && apt-get install -y "$@" ;;
        *)      return 1 ;;
    esac
}

# ── helper : copier un fichier seulement si différent ──────────────────────────
install_file() {
    local src="$1" dst="$2" mode="${3:-644}" owner="${4:-root:root}"
    mkdir -p "$(dirname "$dst")"
    if [ ! -f "$dst" ] || ! diff -q "$src" "$dst" &>/dev/null; then
        install -m "$mode" -o "${owner%%:*}" -g "${owner##*:}" "$src" "$dst"
        log "Installé : $dst"
    else
        skip "$dst"
    fi
}

install_user_file() {
    local src="$1" dst="$2" mode="${3:-644}"
    mkdir -p "$(dirname "$dst")"
    if [ ! -f "$dst" ] || ! diff -q "$src" "$dst" &>/dev/null; then
        install -m "$mode" -o "$TARGET_USER" -g "$TARGET_USER" "$src" "$dst"
        log "Installé (user) : $dst"
    else
        skip "$dst"
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 1. Profil tuned — géré par PPD sur Bazzite, on vérifie juste la config
# ══════════════════════════════════════════════════════════════════════════════
apply_tuned() {
    # Sur Bazzite, PPD gère tuned dynamiquement via /etc/tuned/ppd.conf :
    #   balanced   → balanced-bazzite       (repos)
    #   performance → throughput-performance-bazzite (jeu via gamemode)
    # Ne pas forcer le profil statiquement — PPD l'écraserait.
    if grep -q "throughput-performance-bazzite" /etc/tuned/ppd.conf 2>/dev/null; then
        skip "Tuned (géré par PPD — throughput-performance-bazzite actif en mode performance)"
    else
        warn "Tuned : /etc/tuned/ppd.conf introuvable ou mal configuré"
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 2. Variables gaming (environment.d)
# ══════════════════════════════════════════════════════════════════════════════
apply_env_gaming() {
    install_user_file "$CONFIGS/gaming.conf" \
        "$TARGET_HOME/.config/environment.d/gaming.conf"
}

# ══════════════════════════════════════════════════════════════════════════════
# 3. DRI config — unified heap APU (évite OOM VRAM sur les gros jeux)
# ══════════════════════════════════════════════════════════════════════════════
apply_drirc() {
    install_file "$CONFIGS/drirc" "/etc/drirc"
}

# ══════════════════════════════════════════════════════════════════════════════
# 4. Pipewire latence
# ══════════════════════════════════════════════════════════════════════════════
apply_pipewire() {
    install_user_file "$CONFIGS/pipewire-gaming.conf" \
        "$TARGET_HOME/.config/pipewire/pipewire.conf.d/99-gaming-latency.conf"
}

# ══════════════════════════════════════════════════════════════════════════════
# 4. Sysctl gaming
# ══════════════════════════════════════════════════════════════════════════════
apply_sysctl() {
    local dst="/etc/sysctl.d/99-bc250-gaming.conf"
    install_file "$CONFIGS/sysctl-gaming.conf" "$dst"
    sysctl --system -q 2>/dev/null || true
}

# ══════════════════════════════════════════════════════════════════════════════
# 5. Kargs kernel (méthode auto : rpm-ostree / grubby / GRUB / manuel)
# ══════════════════════════════════════════════════════════════════════════════
apply_kargs() {
    local kargs=(
        "amdgpu.ppfeaturemask=0xffffffff"
        # 8000 (et non 14750) : avec UMA Frame Buffer réservée au BIOS, la RAM
        # système tombe à ~11 Go → un gttsize=14750 dépasse la RAM et fait échouer
        # les allocs GTT (re-crash). 4 Go VRAM + 8 Go GTT = 12 Go VRAM totale.
        "amdgpu.gttsize=8000"
        "split_lock_detect=off"
        "transparent_hugepage=madvise"
        # Masque le spam console au boot — notamment le "RDSEED is not reliable on
        # this platform; disabling." que l'APU custom du BC-250 imprime 1×/cœur très
        # tôt (avant Plymouth). Ne SUPPRIME rien : tout reste dans `journalctl -b`,
        # c'est juste caché de l'écran. (À combiner avec `quiet`, déjà présent.)
        "loglevel=3"
    )

    if [ "$KARG_METHOD" = "manual" ]; then
        warn "Bootloader non reconnu (ni ostree, grubby, GRUB, Limine, systemd-boot, rEFInd)."
        warn "Ajoute ces kargs à la main dans la config de ton bootloader :"
        printf '        %s\n' "${kargs[@]}"
        return
    fi

    # Auto-réparation gttsize : si le cmdline contient une AUTRE valeur de gttsize
    # (ancien 14750, ou doublon d'un re-run), elle n'est jamais nettoyée par le
    # grep de sous-chaîne ci-dessous → kargs en conflit. On retire d'abord toute
    # occurrence de gttsize qui n'est PAS la valeur voulue.
    local stale
    for stale in $(grep -o 'amdgpu\.gttsize=[0-9]*' /proc/cmdline | sort -u); do
        if [ "$stale" != "amdgpu.gttsize=8000" ]; then
            warn "Suppression d'un gttsize périmé/dupliqué : $stale"
            karg_remove "$stale"
        fi
    done

    local current_cmdline karg
    current_cmdline=$(cat /proc/cmdline)
    local missing=()
    for karg in "${kargs[@]}"; do
        echo "$current_cmdline" | grep -q -- "$karg" || missing+=("$karg")
    done

    if [ "${#missing[@]}" -eq 0 ]; then
        skip "Kargs kernel (déjà dans /proc/cmdline)"
        return
    fi

    if karg_add_all "${missing[@]}"; then
        log "Kargs posés via ${KARG_METHOD} : ${missing[*]}"
        warn "Un reboot est nécessaire pour les activer."
    else
        warn "Échec de la pose des kargs (méthode ${KARG_METHOD}) — à ajouter à la main :"
        printf '        %s\n' "${missing[@]}"
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 6. Gamemode
#   - OS mutable (Arch/CachyOS/Fedora/Debian) : installé nativement par le
#     gestionnaire de paquets, gamemoded arrive dans /usr/bin.
#   - OS immuable (Bazzite/SteamOS) : / est en lecture seule → on extrait le RPM
#     dans /usr/local (le seul chemin inscriptible et dans le PATH).
# GAMEMODED_BIN pointe ensuite sur le binaire réel pour le service systemd.
# ══════════════════════════════════════════════════════════════════════════════
GAMEMODED_BIN=""

apply_gamemode() {
    # Déjà présent (natif ou extrait) ?
    if command -v gamemoded >/dev/null 2>&1; then
        GAMEMODED_BIN=$(command -v gamemoded)
        skip "Gamemode ($GAMEMODED_BIN existe)"
        return
    fi
    if [ -x /usr/local/bin/gamemoded ]; then
        GAMEMODED_BIN=/usr/local/bin/gamemoded
        skip "Gamemode (/usr/local/bin/gamemoded existe)"
        return
    fi

    # OS mutable : installation native (propre, mises à jour gérées par la distro).
    if [ "$IS_OSTREE" -eq 0 ] && [ "$PKG_MGR" != "unknown" ]; then
        log "Installation de gamemode via $PKG_MGR..."
        if pkg_install gamemode && command -v gamemoded >/dev/null 2>&1; then
            GAMEMODED_BIN=$(command -v gamemoded)
            log "Gamemode installé ($GAMEMODED_BIN)"
            return
        fi
        warn "Installation native de gamemode échouée — tentative d'extraction RPM..."
    fi

    # OS immuable (ou fallback) : extraction manuelle d'un RPM dans /usr/local.
    # Nécessite dnf (présent sur Bazzite/Fedora). Sinon on abandonne proprement.
    if ! command -v dnf >/dev/null 2>&1; then
        warn "gamemode non installable (ni paquet natif, ni dnf pour extraction) — ignoré."
        return
    fi
    log "Installation de gamemode depuis DNF (extraction manuelle dans /usr/local)..."
    local tmpdir
    tmpdir=$(mktemp -d)
    trap 'rm -rf "$tmpdir"' RETURN

    # Télécharger le RPM gamemode
    local rpm_url
    rpm_url=$(dnf download --url gamemode 2>/dev/null | grep '\.rpm$' | head -1) || true

    if [ -z "$rpm_url" ]; then
        warn "Impossible de trouver le RPM gamemode — installation via dnf download..."
        dnf download gamemode --destdir="$tmpdir" -q
        local rpm_file
        rpm_file=$(ls "$tmpdir"/*.rpm | head -1)
    else
        curl -sL "$rpm_url" -o "$tmpdir/gamemode.rpm"
        local rpm_file="$tmpdir/gamemode.rpm"
    fi

    if [ ! -f "${rpm_file:-}" ]; then
        warn "RPM gamemode introuvable — gamemode non installé."
        return 1
    fi

    # Extraire dans tmpdir
    rpm2cpio "$rpm_file" | cpio -idm -D "$tmpdir" --quiet 2>/dev/null

    # Copier binaires
    for bin in gamemoded gamemoderun gamemodelist; do
        [ -f "$tmpdir/usr/bin/$bin" ] && install -m 755 "$tmpdir/usr/bin/$bin" /usr/local/bin/ && log "  → /usr/local/bin/$bin"
    done

    # Copier libs
    mkdir -p /usr/local/lib64
    find "$tmpdir/usr/lib64" -name "libgamemode*" -exec install -m 755 {} /usr/local/lib64/ \; 2>/dev/null || true
    find "$tmpdir/usr/lib"   -name "libgamemode*" -exec install -m 755 {} /usr/local/lib64/ \; 2>/dev/null || true

    # Copier libexec helpers
    mkdir -p /usr/local/libexec
    for helper in cpugovctl cpucorectl gpuclockctl procsysctl; do
        local found
        found=$(find "$tmpdir" -name "$helper" 2>/dev/null | head -1)
        [ -n "$found" ] && install -m 755 "$found" /usr/local/libexec/ && log "  → /usr/local/libexec/$helper"
    done

    # ldconfig
    echo "/usr/local/lib64" > /etc/ld.so.conf.d/usrlocal.conf
    ldconfig

    [ -x /usr/local/bin/gamemoded ] && GAMEMODED_BIN=/usr/local/bin/gamemoded
    log "Gamemode installé dans /usr/local"
}

# ══════════════════════════════════════════════════════════════════════════════
# 7. Gamemode config + switch scripts
# ══════════════════════════════════════════════════════════════════════════════
apply_gamemode_config() {
    install_file "$CONFIGS/gamemode.ini" "/etc/gamemode.ini"
    install_file "$CONFIGS/gamemode-start.sh" "/usr/local/bin/gamemode-start.sh" "755"
    install_file "$CONFIGS/gamemode-end.sh"   "/usr/local/bin/gamemode-end.sh"   "755"
}

# ══════════════════════════════════════════════════════════════════════════════
# 8. Service systemd user : gamemoded
# ══════════════════════════════════════════════════════════════════════════════
apply_gamemoded_service() {
    # Sans binaire gamemoded (install échouée) : pas de service.
    local bin="${GAMEMODED_BIN:-}"
    [ -n "$bin" ] || bin=$(command -v gamemoded 2>/dev/null || true)
    [ -n "$bin" ] || { [ -x /usr/local/bin/gamemoded ] && bin=/usr/local/bin/gamemoded; }
    if [ -z "$bin" ]; then
        warn "gamemoded introuvable — service non installé."
        return
    fi

    local dst="$TARGET_HOME/.config/systemd/user/gamemoded.service"
    # Le service livré vise /usr/local/bin/gamemoded (cas ostree) ; sur OS mutable
    # le binaire est dans /usr/bin → on réécrit l'ExecStart vers le chemin réel.
    local tmp; tmp=$(mktemp)
    sed "s#^ExecStart=.*#ExecStart=$bin#" "$CONFIGS/gamemoded.service" > "$tmp"
    install_user_file "$tmp" "$dst"
    rm -f "$tmp"
    sudo -u "$TARGET_USER" XDG_RUNTIME_DIR="/run/user/$(id -u "$TARGET_USER")" \
        systemctl --user enable --now gamemoded.service 2>/dev/null || true
    log "Service gamemoded activé ($bin)"
}

# ══════════════════════════════════════════════════════════════════════════════
# 9. HHD state — profil balanced
# ══════════════════════════════════════════════════════════════════════════════
apply_hhd() {
    local hhd_state="/etc/hhd/state.yml"
    if [ -f "$hhd_state" ]; then
        if grep -q "profile: balanced" "$hhd_state"; then
            skip "HHD (balanced déjà configuré)"
        else
            sed -i 's/profile: .*/profile: balanced/' "$hhd_state"
            log "HHD → balanced"
        fi
    else
        skip "HHD ($hhd_state introuvable — HHD non installé ?)"
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 10. scx_loader
# ══════════════════════════════════════════════════════════════════════════════
apply_scx() {
    # Un scheduler déjà chargé garde les options avec lesquelles il a démarré :
    # réécrire le TOML ne suffit pas, il faut le relancer. On repère le cas AVANT
    # d'écrire (sinon install_file a déjà rendu les fichiers identiques).
    local scx_cfg_changed=0
    if ! diff -q "$CONFIGS/scx_loader.toml" "/etc/scx_loader/config.toml" &>/dev/null; then
        scx_cfg_changed=1
    fi
    install_file "$CONFIGS/scx_loader.toml" "/etc/scx_loader/config.toml"
    systemctl enable --now scx_loader.service 2>/dev/null || true
    # scx_loader (Type=dbus) ne charge AUCUN scheduler au boot : il reste on-demand.
    # Le flag --auto désactiverait l'interface D-Bus (scxctl/Steam perdraient le contrôle).
    # → service oneshot qui appelle scxctl start au boot (D-Bus préservé).
    install_file "$CONFIGS/bc250-scx-start.sh" "/usr/local/bin/bc250-scx-start" 755
    install_file "$CONFIGS/bc250-scx-autostart.service" "/etc/systemd/system/bc250-scx-autostart.service"
    systemctl daemon-reload 2>/dev/null || true
    systemctl enable --now bc250-scx-autostart.service 2>/dev/null || true
    if [ "$scx_cfg_changed" = "1" ]; then
        # ⚠️ scx_loader lit son TOML AU DÉMARRAGE et ne le relit jamais : relancer
        # seulement le scheduler redémarrait lavd avec les anciennes options
        # (constaté le 30/08 : --autopower toujours en vigueur après un apply).
        # Il faut donc relancer le loader lui-même.
        systemctl restart scx_loader.service 2>/dev/null || true
        if [ "$(cat /sys/kernel/sched_ext/state 2>/dev/null)" = "enabled" ]; then
            scxctl stop 2>/dev/null || true
            sleep 1
        fi
        # Et on repasse par le script de démarrage, pas par scxctl directement :
        # lui seul sait si le scheduler s'est déjà fait évincer, et recharger un
        # lavd qui cale rendrait la machine à ses gels jusqu'au redémarrage.
        /usr/local/bin/bc250-scx-start 2>/dev/null || true
        log "scx_loader relancé avec les nouvelles options"
    fi
    log "scx_loader activé + autostart scx_lavd au boot"
}

# ══════════════════════════════════════════════════════════════════════════════
# 11. MangoHud
# ══════════════════════════════════════════════════════════════════════════════
apply_mangohud() {
    install_user_file "$CONFIGS/MangoHud.conf" \
        "$TARGET_HOME/.config/MangoHud/MangoHud.conf"
}

# ══════════════════════════════════════════════════════════════════════════════
# 12. vkBasalt
# ══════════════════════════════════════════════════════════════════════════════
apply_vkbasalt() {
    install_user_file "$CONFIGS/vkBasalt.conf" \
        "$TARGET_HOME/.config/vkBasalt.conf"
}

# ══════════════════════════════════════════════════════════════════════════════
# 13. Proton-GE (dernière version depuis GitHub)
# ══════════════════════════════════════════════════════════════════════════════
apply_proton_ge() {
    local compat_dir="$TARGET_HOME/.steam/steam/compatibilitytools.d"
    mkdir -p "$compat_dir"

    # Récupérer la dernière release
    local api latest
    api=$(curl -s "https://api.github.com/repos/GloriousEggroll/proton-ge-custom/releases/latest") || true
    latest=$(printf '%s' "$api" | grep '"tag_name"' | cut -d'"' -f4) || true

    if [ -z "$latest" ]; then
        warn "Impossible de récupérer la version Proton-GE (pas de réseau ?)"
        return 0
    fi

    # ⚠️ Le dossier extrait ne porte PAS le nom du tag : l'archive x86_64 se
    # déplie en GE-Proton11-6-x86_64. Chercher "$compat_dir/$latest" ne trouvait
    # donc jamais rien → réinstallation complète (~400 Mo) à chaque exécution.
    # Le vrai nom est déterminé plus bas, à partir de l'archive elle-même ; ici
    # on accepte les deux formes pour détecter une install existante.
    local dest=""
    local d
    for d in "$compat_dir/$latest" "$compat_dir/$latest"-*; do
        if [ -d "$d" ]; then
            dest="$d"
            break
        fi
    done
    if [ -n "$dest" ]; then
        # Une version antérieure du script extrayait en root sans jamais rendre
        # la main à l'utilisateur : Steam tourne sous son compte et ne peut pas
        # gérer un Proton qui ne lui appartient pas. On répare au passage.
        if [ "$(stat -c %U "$dest" 2>/dev/null)" != "$TARGET_USER" ]; then
            chown -R "$TARGET_USER:$TARGET_USER" "$dest"
            log "Proton-GE $latest : propriétaire corrigé ($TARGET_USER)"
        fi
        skip "Proton-GE ($latest déjà installé)"
        return 0
    fi

    # ⚠️ Ne PAS deviner le nom de l'archive. Depuis GE-Proton11, les assets sont
    # suffixés par architecture (GE-Proton11-6-x86_64.tar.gz) ; les versions
    # antérieures publiaient <tag>.tar.gz. L'URL devinée renvoyait un 404 de
    # 9 octets, que tar refusait — et comme le script tourne en `set -e`, tout
    # s'arrêtait là, sudoers et tweaks suivants compris. On lit donc le nom réel
    # dans la réponse de l'API.
    local arch url
    case "$(uname -m)" in
        x86_64)  arch="x86_64" ;;
        aarch64) arch="aarch64" ;;
        *)       arch="$(uname -m)" ;;
    esac
    url=$(printf '%s' "$api" \
        | grep -o '"browser_download_url": *"[^"]*\.tar\.gz"' \
        | cut -d'"' -f4 | grep -- "-${arch}\.tar\.gz$" | head -1) || true
    if [ -z "$url" ]; then
        # Releases d'avant la séparation par architecture.
        url=$(printf '%s' "$api" \
            | grep -o '"browser_download_url": *"[^"]*\.tar\.gz"' \
            | cut -d'"' -f4 | grep -- "/${latest}\.tar\.gz$" | head -1) || true
    fi
    if [ -z "$url" ]; then
        warn "Aucune archive Proton-GE pour $arch dans la release $latest — ignoré"
        return 0
    fi

    log "Téléchargement Proton-GE $latest ($arch)..."
    local tmpfile
    tmpfile=$(mktemp /tmp/proton-ge-XXXXXX.tar.gz)
    # -f : une erreur HTTP devient un échec de curl au lieu d'un fichier d'erreur
    # sauvegardé sur le disque et passé à tar.
    if ! curl -fsSL "$url" -o "$tmpfile"; then
        warn "Téléchargement de Proton-GE $latest échoué — ignoré"
        rm -f "$tmpfile"
        return 0
    fi

    # Vérification d'intégrité quand la release publie une somme (elles le font
    # toutes depuis GE-Proton9) : une archive tronquée casse Steam en silence.
    local sumurl expected actual
    sumurl=$(printf '%s' "$api" \
        | grep -o '"browser_download_url": *"[^"]*\.sha512sum"' \
        | cut -d'"' -f4 | grep -- "-${arch}\.sha512sum$" | head -1) || true
    if [ -n "$sumurl" ]; then
        expected=$(curl -fsSL "$sumurl" 2>/dev/null | awk '{print $1}' | head -1) || true
        actual=$(sha512sum "$tmpfile" | awk '{print $1}')
        if [ -n "$expected" ] && [ "$expected" != "$actual" ]; then
            warn "Somme sha512 incorrecte pour Proton-GE $latest — archive ignorée"
            rm -f "$tmpfile"
            return 0
        fi
    fi

    # Nom réel du dossier, lu dans l'archive : c'est lui qu'il faudra donner à
    # l'utilisateur, et c'est lui que la prochaine exécution devra reconnaître.
    local topdir
    topdir=$(tar -tzf "$tmpfile" 2>/dev/null | head -1 | cut -d/ -f1) || true

    if ! tar -xzf "$tmpfile" -C "$compat_dir"; then
        warn "Extraction de Proton-GE $latest échouée — ignoré"
        rm -f "$tmpfile"
        return 0
    fi
    rm -f "$tmpfile"
    if [ -n "$topdir" ] && [ -d "$compat_dir/$topdir" ]; then
        chown -R "$TARGET_USER:$TARGET_USER" "$compat_dir/$topdir"
    else
        warn "Proton-GE $latest extrait, mais dossier introuvable — propriétaire non corrigé"
    fi
    log "Proton-GE $latest installé dans $compat_dir"
}

# ══════════════════════════════════════════════════════════════════════════════
# 14. bc250-cu-live-manager (gestionnaire de CU/WGP via UMR)
# ══════════════════════════════════════════════════════════════════════════════
apply_umr_sudoers() {
    local sudoers_file="/etc/sudoers.d/bc250-umr"
    local expected_line="$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/umr"

    if [ -f "$sudoers_file" ] && grep -qF "$expected_line" "$sudoers_file" 2>/dev/null; then
        skip "sudoers umr ($sudoers_file déjà configuré)"
        return
    fi

    echo "$expected_line" > "$sudoers_file"
    chmod 440 "$sudoers_file"
    log "sudoers umr configuré : $TARGET_USER peut lancer umr sans mot de passe"
}

apply_cu_boot_sudoers() {
    local sudoers_file="/etc/sudoers.d/bc250-cu-boot"
    local marker="bc250-cu-boot-sudoers-v1"

    if [ -f "$sudoers_file" ] && grep -qF "$marker" "$sudoers_file" 2>/dev/null; then
        skip "sudoers cu-boot ($sudoers_file déjà configuré)"
        return
    fi

    cat > "$sudoers_file" <<EOF
# $marker — BC250-Toolkit-Decky : persistance profil CU au boot
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /usr/local/bin/bc250-cu-restore
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/chmod 755 /usr/local/bin/bc250-cu-restore
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /etc/systemd/system/bc250-cu-profile.service
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/systemctl daemon-reload
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/systemctl enable bc250-cu-profile.service
EOF
    chmod 440 "$sudoers_file"
    log "sudoers cu-boot configuré : $TARGET_USER peut écrire le service CU boot sans mot de passe"
}

apply_core_boot_sudoers() {
    local sudoers_file="/etc/sudoers.d/bc250-core-boot"
    local marker="bc250-core-boot-sudoers-v1"

    if [ -f "$sudoers_file" ] && grep -qF "$marker" "$sudoers_file" 2>/dev/null; then
        skip "sudoers core-boot ($sudoers_file déjà configuré)"
        return
    fi

    # Persistance du déverrouillage 8C/16T. Contrairement aux CU (pokés à chaud),
    # les cœurs n'apparaissent qu'au redémarrage suivant : le service écrit le
    # masque puis redémarre UNE fois, avec un plafond de 2 tentatives. Les
    # scripts sont recopiés hors du dossier du plugin, que Decky réécrit.
    cat > "$sudoers_file" <<EOF
# $marker — BC250-Toolkit-Decky : persistance du déverrouillage CPU au boot
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/mkdir -p /usr/local/lib/bc250-core-unlock
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /usr/local/lib/bc250-core-unlock/bc250-core-status.py
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /usr/local/lib/bc250-core-unlock/bc250-unlock-cores.py
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /usr/local/bin/bc250-core-boot
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/chmod 755 /usr/local/bin/bc250-core-boot
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/tee /etc/systemd/system/bc250-core-unlock.service
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/systemctl daemon-reload
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/systemctl enable bc250-core-unlock.service
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/systemctl disable bc250-core-unlock.service
$TARGET_USER ALL=(root) NOPASSWD: /usr/bin/rm -f /var/lib/bc250-core-unlock/attempts
EOF
    chmod 440 "$sudoers_file"
    log "sudoers core-boot configuré : $TARGET_USER peut installer le service 8C/16T sans mot de passe"
}

apply_cu_manager() {
    local dst="/usr/local/bin/bc250-cu-live-manager"

    if [ -x "$dst" ]; then
        skip "bc250-cu-live-manager ($dst déjà installé)"
        return
    fi

    # Priorité : copie locale si présente
    local local_src="$TARGET_HOME/bc250-cu-live-manager.sh"
    if [ -f "$local_src" ]; then
        install -m 0755 "$local_src" "$dst"
        log "bc250-cu-live-manager installé depuis $local_src"
        return
    fi

    # Sinon télécharger depuis GitHub (WinnieLV/bc250-cu-live-manager)
    log "Téléchargement de bc250-cu-live-manager depuis GitHub..."
    local url="https://raw.githubusercontent.com/WinnieLV/bc250-cu-live-manager/main/bc250-cu-live-manager.sh"
    if curl -sL "$url" -o "$dst" 2>/dev/null && [ -s "$dst" ]; then
        chmod 0755 "$dst"
        log "bc250-cu-live-manager installé dans $dst"
    else
        rm -f "$dst"
        warn "Impossible d'installer bc250-cu-live-manager (pas de réseau ?)"
    fi
}

# ══════════════════════════════════════════════════════════════════════════════
# 15. bc250-uma-helper (écriture UMA Frame Buffer via efivar AmdSetup — Toolkit)
# ══════════════════════════════════════════════════════════════════════════════
apply_uma_helper() {
    install_file "$CONFIGS/bc250-uma-helper" /usr/local/bin/bc250-uma-helper 755
}

apply_uma_sudoers() {
    local sudoers_file="/etc/sudoers.d/bc250-uma"
    local marker="bc250-uma-sudoers-v1"

    if [ -f "$sudoers_file" ] && grep -qF "$marker" "$sudoers_file" 2>/dev/null; then
        skip "sudoers uma ($sudoers_file déjà configuré)"
        return
    fi

    cat > "$sudoers_file" <<EOF
# $marker — BC250-Toolkit-Decky : lecture/écriture UMA (efivar AmdSetup)
$TARGET_USER ALL=(root) NOPASSWD: /usr/local/bin/bc250-uma-helper
EOF
    chmod 440 "$sudoers_file"
    log "sudoers uma configuré : $TARGET_USER peut lancer bc250-uma-helper sans mot de passe"
}

# ══════════════════════════════════════════════════════════════════════════════
# 16. DeckyLoader + nos plugins (setup complet du BC-250 en une commande)
# ══════════════════════════════════════════════════════════════════════════════
# Installe DeckyLoader s'il manque, puis nos plugins (BC250-Toolkit, SkullKey,
# Steamcord) depuis leurs releases GitHub. UNE SEULE FOIS : si un plugin est
# déjà présent on ne touche à rien (l'auto-update de Decky, basé sur les
# releases, prend le relais — on ne veut pas réécrire/écraser à chaque boot).
apply_deckyloader() {
    if systemctl is-active --quiet plugin_loader 2>/dev/null \
            || [ -d "$TARGET_HOME/homebrew/services" ]; then
        skip "DeckyLoader (déjà installé)"
        return
    fi
    log "Installation de DeckyLoader…"
    # Installeur officiel : installe dans ~/homebrew et pose plugin_loader.service.
    # apply.sh tourne en root → on fixe HOME sur l'utilisateur cible.
    if HOME="$TARGET_HOME" curl -fsSL \
        "https://github.com/SteamDeckHomebrew/decky-loader/raw/main/dist/install_release.sh" \
        | HOME="$TARGET_HOME" sh 2>&1 | sed 's/^/    /'; then
        [ -d "$TARGET_HOME/homebrew" ] && chown -R "$TARGET_USER:$TARGET_USER" \
            "$TARGET_HOME/homebrew" 2>/dev/null || true
        log "DeckyLoader installé"
    else
        warn "DeckyLoader : installation échouée (pas de réseau ?)"
    fi
}

_install_plugin() {
    local name="$1" repo="$2" zip="$3"
    local dst="$TARGET_HOME/homebrew/plugins"
    if [ ! -d "$dst" ]; then
        skip "Plugin $name (DeckyLoader pas prêt)"
        return
    fi
    if [ -d "$dst/$name" ]; then
        skip "Plugin $name (déjà présent — l'auto-update Decky s'en charge)"
        return
    fi
    local tmp; tmp=$(mktemp -d)
    local url="https://github.com/${repo}/releases/latest/download/${zip}"
    if curl -fsSL "$url" -o "$tmp/$zip" 2>/dev/null \
            && unzip -q "$tmp/$zip" -d "$tmp/x" 2>/dev/null; then
        local inner
        inner=$(find "$tmp/x" -maxdepth 1 -mindepth 1 -type d | head -1)
        [ -n "$inner" ] || inner="$tmp/x"
        cp -r "$inner" "$dst/$name"
        chown -R "$TARGET_USER:$TARGET_USER" "$dst/$name"
        find "$dst/$name" \( -name '*.sh' -o -name '*.py' \) -exec chmod a+rx {} + 2>/dev/null || true
        log "Plugin installé : $name"
    else
        warn "Plugin $name : téléchargement/extraction échoué (pas de réseau ?)"
    fi
    rm -rf "$tmp"
}

apply_our_plugins() {
    _install_plugin "BC250-Toolkit" "Necrosiak/bc250-toolkit-decky" "BC250-Toolkit.zip"
    _install_plugin "SkullKey"      "Necrosiak/SkullKey"            "SkullKey.zip"
    _install_plugin "Steamcord"     "Necrosiak/Steamcord"          "Steamcord.zip"
}

# ══════════════════════════════════════════════════════════════════════════════
# 17. uaccess clavier/souris (raccourci vocal Steamcord en jeu)
# ══════════════════════════════════════════════════════════════════════════════
# Bazzite n'accorde `uaccess` qu'aux joysticks (70-uaccess.rules ligne 61) et ne
# livre pas le 70-steam-jupiter-input.rules de SteamOS → un plugin Decky non
# privilégié ne peut pas lire /dev/input/event* pour un clavier ou une souris.
# Voir configs/70-bc250-input-uaccess.rules pour le compromis de sécurité.
apply_input_uaccess() {
    local dst="/etc/udev/rules.d/70-bc250-input-uaccess.rules"
    install_file "$CONFIGS/70-bc250-input-uaccess.rules" "$dst" 644
    # Reprise à chaud : sans ça la règle ne prendrait qu'au prochain rebranchement
    # (ou au reboot), et l'utilisateur croirait le tweak inopérant.
    udevadm control --reload-rules 2>/dev/null || true
    udevadm trigger --subsystem-match=input 2>/dev/null || true
    log "uaccess clavier/souris actif — voir l'avertissement en tête de $dst"
}

# ── commande « bc250-status » : résumé santé (temps/ventilo/UMA/tweaks/plugins) ─
apply_status_command() {
    [ -f "$REPO_DIR/status.sh" ] && \
        install_file "$REPO_DIR/status.sh" /usr/local/bin/bc250-status 755
}

# ══════════════════════════════════════════════════════════════════════════════
# MAIN
# ══════════════════════════════════════════════════════════════════════════════
main() {
    need_root
    detect_os

    echo ""
    echo "═══════════════════════════════════════════════════"
    echo "  BC-250 Tweaks — apply.sh"
    echo "  Utilisateur cible : $TARGET_USER ($TARGET_HOME)"
    echo "  OS : $OS_NAME (id=$OS_ID$([ -n "$OS_LIKE" ] && echo ", like=$OS_LIKE"))"
    echo "  Immuable : $([ "$IS_OSTREE" -eq 1 ] && echo oui || echo non)"\
"  ·  Paquets : $PKG_MGR  ·  Kargs : $KARG_METHOD"
    echo "═══════════════════════════════════════════════════"
    echo ""

    if [ "$IS_OSTREE" -eq 0 ] && [[ "$OS_ID" != "bazzite" && "$OS_LIKE" != *fedora* ]]; then
        warn "OS hors Bazzite/SteamOS : support best-effort (validé par les retours"
        warn "de la communauté). Signale tout souci : github.com/Necrosiak/bc250-tweaks/issues"
        echo ""
    fi

    apply_tuned
    apply_env_gaming
    apply_drirc
    apply_pipewire
    apply_sysctl
    apply_kargs
    apply_gamemode
    apply_gamemode_config
    apply_gamemoded_service
    apply_hhd
    apply_scx
    apply_mangohud
    apply_vkbasalt
    apply_proton_ge
    apply_umr_sudoers
    apply_cu_boot_sudoers
    apply_core_boot_sudoers
    apply_cu_manager
    apply_uma_helper
    apply_uma_sudoers
    apply_input_uaccess
    apply_deckyloader
    apply_our_plugins
    apply_status_command

    echo ""
    echo "═══════════════════════════════════════════════════"
    echo "  Terminé.  ${TERM:+Tape }bc250-status pour un résumé santé."
    echo "  Si des kargs ont été ajoutés, redémarre la machine."
    echo "═══════════════════════════════════════════════════"
}

main "$@"