#!/bin/bash
# =============================================================================
# pagan-mkiso — zamróz uruchomiony PaganOS w bootowalne, hybrydowe ISO
# =============================================================================
# Robi squashfs z działającego systemu i opakowuje go w ISO startujące przez
# BIOS (isolinux) ORAZ UEFI (GRUB). Nadaje się do postawienia kolejnej maszyny
# albo jako baza własnej dystrybucji.
#
# Samowystarczalny: sam buduje LIVE-initramfs (busybox + własny /init obsługujący
# squashfs + overlay + findiso), więc nie zależy od initramfsu dyskowego.
#
# Użycie:
#   sudo pagan-mkiso                         # ISO z uruchomionego systemu
#   sudo pagan-mkiso -o ~/Pagan.iso          # własna ścieżka wyjścia
#   sudo pagan-mkiso --initramfs FILE        # użyj gotowego (live) initramfs
#   sudo pagan-mkiso --check                 # sprawdź narzędzia, nic nie buduj
#   sudo pagan-mkiso --gui                   # proste okno GTK (jeśli dostępne)
#   pagan-mkiso --help
#
# Konfiguracja: /etc/pagan/mkiso.conf (wzór: /usr/share/pagan/mkiso.conf.example)
# =============================================================================
set -uo pipefail

# ---------- kolory / logi ----------
if [[ -t 1 ]]; then
    R=$'\033[91m'; G=$'\033[92m'; Y=$'\033[93m'; B=$'\033[94m'; BOLD=$'\033[1m'; N=$'\033[0m'
else
    R=""; G=""; Y=""; B=""; BOLD=""; N=""
fi
info() { printf '%s[pagan-mkiso]%s %s\n' "$B" "$N" "$*"; }
ok()   { printf '%s[pagan-mkiso]%s %s✅%s %s\n' "$B" "$N" "$G" "$N" "$*"; }
warn() { printf '%s[pagan-mkiso]%s %s⚠%s %s\n' "$B" "$N" "$Y" "$N" "$*" >&2; }
die()  { printf '%s[pagan-mkiso]%s BŁĄD: %s\n' "$B" "$R$N" "$*" >&2; exit 1; }

# ---------- domyślne / konfiguracja ----------
MKISO_OUT=""
MKISO_LABEL="PAGANLIVE"
MKISO_KERNEL=""
MKISO_INITRAMFS=""
MKISO_COMP="xz -b 1M -Xdict-size 100% -noappend"
MKISO_DE=""
MKISO_DO_BIOS=1
MKISO_DO_UEFI=1
MKISO_ASSUME_YES=0
# 1 = dołącz /home i /root do obrazu. Domyślnie NIE (prywatność: dane użytkownika,
# klucze SSH, profile przeglądarki, hasła…).
# shellcheck disable=SC1091
[[ -r /etc/pagan/mkiso.conf ]] && source /etc/pagan/mkiso.conf

# ---------- argumenty ----------
DO_CHECK=0
DO_GUI=0
while [[ $# -gt 0 ]]; do
    case "$1" in
        -o|--output)    MKISO_OUT="$2"; shift 2 ;;
        -l|--label)     MKISO_LABEL="$2"; shift 2 ;;
        -k|--kernel)    MKISO_KERNEL="$2"; shift 2 ;;
        -i|--initramfs) MKISO_INITRAMFS="$2"; shift 2 ;;
        -c|--compress)  MKISO_COMP="$2"; shift 2 ;;
        --de)           MKISO_DE="$2"; shift 2 ;;
        --include-home) MKISO_INCLUDE_HOME=1; shift ;;
        --no-bios)      MKISO_DO_BIOS=0; shift ;;
        --no-uefi)      MKISO_DO_UEFI=0; shift ;;
        --check)        DO_CHECK=1; shift ;;
        --gui)          DO_GUI=1; shift ;;
        -y|--yes)       MKISO_ASSUME_YES=1; shift ;;
        -h|--help)      sed -n '2,20p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
        *)              die "Nieznana opcja: $1 (użyj --help)" ;;
    esac
done

# ---------- GUI (opcjonalne) ----------
if [[ $DO_GUI -eq 1 ]]; then
    for _g in /usr/lib/pagan/pagan-mkiso-gui.py /usr/share/pagan/pagan-mkiso-gui.py; do
        if [[ -f "$_g" ]]; then exec python3 "$_g" "$@"; fi
    done
    warn "brak pagan-mkiso-gui.py – uruchamiam tryb tekstowy"
fi

[[ "$(id -u)" = "0" ]] || die "Uruchom jako root (sudo pagan-mkiso)"

# ---------- wymagane narzędzia ----------
_have() { command -v "$1" >/dev/null 2>&1; }
_missing_tools() {
    local _m=""
    for t in mksquashfs xorriso; do _have "$t" || _m="$_m $t"; done
    # busybox do zbudowania initramfs; jeśli brak, spróbujemy kopii binarek hosta
    _have busybox || _have /usr/bin/busybox || _m="$_m busybox"
    printf '%s' "$_m"
}
_find_syslinux() {
    local f="$1" d
    for d in /usr/lib/syslinux/bios /usr/lib/syslinux /usr/lib/syslinux/modules/bios \
             /usr/share/syslinux /usr/lib/ISOLINUX /usr/lib/syslinux/mbr; do
        [[ -f "$d/$f" ]] && { printf '%s' "$d/$f"; return 0; }
    done
    return 1
}

if [[ $DO_CHECK -eq 1 ]]; then
    MISSING="$(_missing_tools)"
    if [[ -n "$MISSING" ]]; then
        warn "brakujące narzędzia:$MISSING"
        die "doinstaluj: sudo pag install pagan-mkiso (albo squashfs-tools libisoburn busybox)"
    fi
    for f in isolinux.bin ldlinux.c32 isohdpfx.bin; do
        _find_syslinux "$f" >/dev/null || warn "brak pliku syslinux: $f (BIOS ISO nie powstanie)"
    done
    [[ -e /usr/lib/grub/x86_64-efi ]] || warn "brak /usr/lib/grub/x86_64-efi (UEFI pominięte)"
    ok "narzędzia obecne"
    exit 0
fi

MISSING="$(_missing_tools)"
[[ -z "$MISSING" ]] || die "brak narzędzi:$MISSING — doinstaluj: sudo pag install pagan-mkiso"

# ---------- wykrycie jądra i initramfs (FIX: per-wersja) ----------
KREL="$(uname -r)"
_detect_kernel() {
    [[ -n "$MKISO_KERNEL" ]] && { printf '%s' "$MKISO_KERNEL"; return; }
    local c
    for c in /boot/vmlinuz-linux "/boot/vmlinuz-$KREL" /boot/vmlinuz-*; do
        [[ -f "$c" || -L "$c" ]] && { printf '%s' "$c"; return; }
    done
}
_detect_initramfs() {
    # Bierzemy TYLKO initramfs LIVE. Klasyczny /boot/initramfs.img to live-initramfs
    # z ISO (obsługuje squashfs+overlay). Initramfsy per-wersja (/boot/initramfs-<ver>.img
    # z pagan-initramfs) są DYSKOWE (root=/LUKS) i NIE wystartują jako live — dlatego
    # ich NIE bierzemy: gdy brak live, zbudujemy własny (patrz build_live_initramfs).
    [[ -n "$MKISO_INITRAMFS" ]] && { printf '%s' "$MKISO_INITRAMFS"; return; }
    if [[ -e /boot/initramfs.img ]]; then printf '%s' /boot/initramfs.img; return; fi
}

KERNEL="$(_detect_kernel)"
[[ -n "$KERNEL" && -e "$KERNEL" ]] || die "Nie znalazłem jądra (--kernel PLIK). Sprawdź /boot/vmlinuz-linux."
KERNEL="$(readlink -f "$KERNEL")"

INITRAMFS="$(_detect_initramfs)"
# Nie przerywamy, gdy brak initramfs — zbudujemy własny LIVE poniżej.

# ---------- wykrycie rozmiaru / punktu pracy ----------
host_arch="$(uname -m)"
[[ "$host_arch" = "x86_64" || "$host_arch" = "i686" ]] || die "Obsługiwane tylko x86/x86_64 (jest: $host_arch)"

# ---------- przygotowanie katalogu pracy ----------
WORK="$(mktemp -d /var/tmp/pagan-mkiso.XXXXXX)" || die "nie mogę utworzyć katalogu pracy"
cleanup() { [[ "${KEEP_WORK:-0}" = "1" ]] || rm -rf "$WORK"; }
trap cleanup EXIT
ISODIR="$WORK/iso"
mkdir -p "$ISODIR/boot" "$ISODIR/live" "$ISODIR/isolinux"

[[ -n "$MKISO_OUT" ]] || MKISO_OUT="$HOME/Pagan-Linux-$(date +%Y.%m.%d)-live.iso"

info "jądro:     $KERNEL"
[[ -n "$INITRAMFS" ]] && info "initramfs: $INITRAMFS" || info "initramfs: (brak — zbuduję LIVE)"

# =============================================================================
# 1) LIVE-initramfs (jeśli nie podano) — busybox + własny /init (squashfs+overlay)
# =============================================================================
build_live_initramfs() {
    local idir="$WORK/initramfs" out="$WORK/initramfs.img"
    info "buduję LIVE-initramfs (busybox + live init)..."
    rm -rf "$idir"; mkdir -p "$idir"/{bin,sbin,usr/bin,usr/sbin,dev,proc,sys,run,etc,new_root,lower,overlay,mnt}

    # --- /init ---
    cat > "$idir/init" <<'INITEOF'
#!/bin/sh
export PATH=/usr/sbin:/usr/bin:/sbin:/bin
mount -t proc proc /proc 2>/dev/null
mount -t sysfs sysfs /sys 2>/dev/null
mount -t devtmpfs dev /dev 2>/dev/null || mount -t tmpfs dev /dev 2>/dev/null
mkdir -p /run /new_root /lower /overlay /mnt /etc

LIVE=0; ROOT_DEV=""; CRYPT_DEV_ARG=""; FINDISO=""; IMG_DEV=""; _join=""
set -- $(cat /proc/cmdline 2>/dev/null)
for arg in "$@"; do
    if [ -n "$_join" ]; then
        case "$arg" in
            *=*) _join="" ;;
            *)   case "$_join" in
                     FINDISO) FINDISO="$FINDISO $arg" ;;
                     IMG_DEV) IMG_DEV="$IMG_DEV $arg" ;;
                 esac
                 continue ;;
        esac
    fi
    case "$arg" in
        pagan.live|live) LIVE=1 ;;
        root=*) ROOT_DEV="${arg#root=}" ;;
        cryptdevice=*) CRYPT_DEV_ARG="${arg#cryptdevice=}" ;;
        findiso=*) FINDISO="${arg#findiso=}"; _join=FINDISO ;;
        iso-scan/filename=*) FINDISO="${arg#iso-scan/filename=}"; _join=FINDISO ;;
        img_dev=*) IMG_DEV="${arg#img_dev=}"; _join=IMG_DEV ;;
    esac
done
[ -n "$FINDISO" ] && command -v sed >/dev/null 2>&1 && FINDISO="$(printf '%s' "$FINDISO" | sed 's/\\ / /g')"

SFS="live/filesystem.squashfs"

_ro_mount() {  # $1=dev $2=punkt
    case "$1" in
        /dev/sr*|/dev/cdrom)
            for t in iso9660 udf; do mount -t "$t" -o ro "$1" "$2" 2>/dev/null && return 0; done ;;
        *)
            mount -t auto -o ro "$1" "$2" 2>/dev/null && return 0
            for t in exfat vfat ntfs3 ntfs iso9660; do mount -t "$t" -o ro "$1" "$2" 2>/dev/null && return 0; done ;;
    esac
    return 1
}
_try_medium() {  # $1=dev; sukces: LIVE_DEV/LIVE_ISO ustawione
    [ -b "$1" ] || return 1
    _ro_mount "$1" /mnt || return 1
    if [ -f "/mnt/$SFS" ]; then LIVE_DEV="$1"; LIVE_ISO=""; umount /mnt 2>/dev/null; return 0; fi
    if [ -n "$FINDISO" ] && [ -f "/mnt/$FINDISO" ]; then LIVE_DEV="$1"; LIVE_ISO="$FINDISO"; umount /mnt 2>/dev/null; return 0; fi
    umount /mnt 2>/dev/null; return 1
}

LIVE_DEV=""; LIVE_ISO=""
if [ "$LIVE" = "1" ]; then
    echo "[pagan-init] Tryb LIVE"
    # kolejność: dm/Ventoy, CD, nośniki wymienne, na końcu img_dev
    for _d in $IMG_DEV /dev/sr* /dev/dm-* /dev/mapper/*; do
        [ -e "$_d" ] || continue
        _try_medium "$_d" && break
    done
    if [ -z "$LIVE_DEV" ]; then
        for _s in /sys/block/*; do
            [ "$(cat "$_s/removable" 2>/dev/null)" = "1" ] || continue
            _b="/dev/${_s##*/}"
            for _p in "$_b"?* "$_b"; do [ -e "$_p" ] && { _try_medium "$_p" && break; }; done
            [ -n "$LIVE_DEV" ] && break
        done
    fi
    [ -n "$LIVE_DEV" ] || { echo "[pagan-init] BŁĄD: nie znalazłem nośnika live. Powłoka:"; exec /bin/sh; }

    mkdir -p /run/media
    _ro_mount "$LIVE_DEV" /run/media || { echo "[pagan-init] BŁĄD: nie mogę zamontować $LIVE_DEV"; exec /bin/sh; }
    SFSFILE="/run/media/$SFS"
    if [ -n "$LIVE_ISO" ]; then
        # nośnik danych z plikiem ISO -> losetup + iso9660
        for L in /dev/loop0 /dev/loop1 /dev/loop2 /dev/loop3; do
            [ -e "$L" ] || mknod "$L" b 7 "${L#/dev/loop}" 2>/dev/null
            if losetup "$L" "/run/media/$LIVE_ISO" 2>/dev/null; then
                mkdir -p /run/iso
                mount -t iso9660 -o ro "$L" /run/iso 2>/dev/null && { SFSFILE="/run/iso/$SFS"; break; }
                losetup -d "$L" 2>/dev/null
            fi
        done
    fi
    [ -f "$SFSFILE" ] || { echo "[pagan-init] BŁĄD: brak $SFS na nośniku. Powłoka:"; exec /bin/sh; }

    # squashfs (loop) + overlay (tmpfs) + switch_root
    mount -t squashfs -o loop,ro "$SFSFILE" /lower 2>/dev/null || \
        { LOS=$(losetup -f 2>/dev/null); losetup "$LOS" "$SFSFILE" 2>/dev/null; mount -t squashfs -o ro "$LOS" /lower; }
    mount -t tmpfs -o mode=0755 tmpfs /overlay
    mkdir -p /overlay/upper /overlay/work
    mount -t overlay overlay -o lowerdir=/lower,upperdir=/overlay/upper,workdir=/overlay/work /new_root || \
        { echo "[pagan-init] BŁĄD: overlay na /new_root"; exec /bin/sh; }
    mount --move /proc /new_root/proc 2>/dev/null
    mount --move /sys  /new_root/sys  2>/dev/null
    mount --move /dev  /new_root/dev  2>/dev/null
    echo "[pagan-init] LIVE gotowy – switch_root"
    exec switch_root /new_root /sbin/init
fi

# ================= TRYB DYSK =================
[ -n "$ROOT_DEV" ] || ROOT_DEV="/dev/sda1"
_blkid_get() { blkid "$1" 2>/dev/null | tr ' ' '\n' | grep "^$2=" | head -1 | cut -d= -f2- | tr -d '"'; }
_resolve_root() {
    local key="$1" val="$2" d
    for d in /dev/sd*[0-9] /dev/hd*[0-9] /dev/vd*[0-9] /dev/nvme*n[0-9]*p[0-9]* /dev/mmcblk*p[0-9]* /dev/dm-[0-9]* /dev/mapper/*; do
        [ -b "$d" ] || continue
        [ "$(_blkid_get "$d" "$key")" = "$val" ] && { printf '%s' "$d"; return 0; }
    done
    return 1
}
case "$ROOT_DEV" in
    UUID=*)     _r="$(_resolve_root UUID "${ROOT_DEV#UUID=}")"         && ROOT_DEV="$_r" ;;
    PARTUUID=*) _r="$(_resolve_root PARTUUID "${ROOT_DEV#PARTUUID=}")" && ROOT_DEV="$_r" ;;
    LABEL=*)    _r="$(_resolve_root LABEL "${ROOT_DEV#LABEL=}")"       && ROOT_DEV="$_r" ;;
esac
if command -v cryptsetup >/dev/null 2>&1 && cryptsetup isLuks "$ROOT_DEV" 2>/dev/null; then
    modprobe dm-crypt 2>/dev/null || true
    stty -echo 2>/dev/null; printf "Hasło (LUKS %s): " "$ROOT_DEV"; read -r _p; stty echo 2>/dev/null; echo
    printf '%s\n' "$_p" | cryptsetup open "$ROOT_DEV" cryptroot 2>/dev/null && ROOT_DEV="/dev/mapper/cryptroot"
    _p=""
fi
i=0; while [ ! -e "$ROOT_DEV" ] && [ "$i" -lt 10 ]; do sleep 1; i=$((i+1)); done
mount -t auto -o rw "$ROOT_DEV" /new_root 2>/dev/null || { echo "[pagan-init] BŁĄD: nie zamontuję $ROOT_DEV"; exec /bin/sh; }
ACTIVE="/new_root/.deployments/active"; NEWROOT="/new_root"
if [ -L "$ACTIVE" ]; then _d=$(readlink "$ACTIVE"); [ -n "$_d" ] && NEWROOT="/new_root/.deployments/$_d"; fi
mount --move /proc "$NEWROOT/proc" 2>/dev/null
mount --move /sys  "$NEWROOT/sys"  2>/dev/null
mount --move /dev  "$NEWROOT/dev"  2>/dev/null
exec switch_root "$NEWROOT" /sbin/init
INITEOF
    chmod 755 "$idir/init"

    # busybox + applety
    local BB=""
    for p in /usr/bin/busybox /bin/busybox /sbin/busybox; do [[ -x "$p" ]] && BB="$p" && break; done
    [[ -n "$BB" ]] || die "brak busybox — doinstaluj: sudo pag install busybox"
    cp "$BB" "$idir/bin/busybox"; chmod 755 "$idir/bin/busybox"
    # gdy busybox jest dynamiczny – dociągnij jego biblioteki + loader
    if ! ldd "$BB" 2>/dev/null | grep -q 'not a dynamic executable\|statically linked'; then
        local _lib _d _ld
        for _lib in $(ldd "$BB" 2>/dev/null | awk '/=>[[:space:]]*\// {print $3}'); do
            [[ -f "$_lib" ]] || continue; _d="${_lib#/}"; mkdir -p "$idir/${_d%/*}"; cp -fL "$_lib" "$idir/$_d" 2>/dev/null || true
        done
        _ld="$(ldd "$BB" 2>/dev/null | awk '/ld-linux/ {print $1}')"
        [[ -f "$_ld" ]] && { mkdir -p "$idir${_ld%/*}"; cp -fL "$_ld" "$idir$_ld" 2>/dev/null || true; }
    fi
    local c
    for c in sh mount umount ls cat echo sleep readlink mkdir switch_root cp rm ln grep \
             poweroff reboot blkid mknod stty sed sort cut tr head losetup find; do
        ln -sf busybox "$idir/bin/$c"
    done

    # opcjonalnie cryptsetup (LUKS) + jego biblioteki
    local CS=""
    for p in /usr/sbin/cryptsetup /usr/bin/cryptsetup /sbin/cryptsetup; do [[ -x "$p" ]] && CS="$p" && break; done
    if [[ -n "$CS" ]]; then
        cp "$CS" "$idir/usr/sbin/cryptsetup"; chmod 755 "$idir/usr/sbin/cryptsetup"
        local lib d
        for lib in $(ldd "$CS" 2>/dev/null | awk '/=>[[:space:]]*\// {print $3}'); do
            [[ -f "$lib" ]] || continue; d="${lib#/}"; mkdir -p "$idir/${d%/*}"; cp -fL "$lib" "$idir/$d" 2>/dev/null || true
        done
    fi

    # moduły jądra dla DZIAŁAJĄCEGO jądra (best-effort; squashfs/overlay/iso9660/loop
    # są wbudowane w jądro Pagan, ale kopiujemy moduły na wypadek LUKS/USB itd.)
    local kver="$KREL"
    if [[ -d "/usr/lib/modules/$kver" ]] && command -v busybox >/dev/null 2>&1; then
        # świadomie NIE kopiujemy całego drzewa modułów (rozmiar) – live i tak używa
        # tego, co wbudowane; cryptsetup/dm-crypt doładowywane z jądra.
        mkdir -p "$idir/lib/modules/$kver"
        for m in kernel/drivers/md/dm-crypt.ko* kernel/crypto/*/*.ko* kernel/fs/squashfs/squashfs.ko*; do
            [[ -e "/usr/lib/modules/$kver/$m" ]] || continue
            mkdir -p "$idir/lib/modules/$kver/$(dirname "$m")"
            cp -f "/usr/lib/modules/$kver/$m" "$idir/lib/modules/$kver/$m" 2>/dev/null || true
        done
    fi

    ( cd "$idir" && find . | cpio -oH newc 2>/dev/null | gzip -1 ) > "$out" || die "budowa initramfs nieudana"
    [[ -s "$out" ]] || die "initramfs pusty"
    INITRAMFS="$out"
    ok "LIVE-initramfs: $out ($(du -h "$out" | cut -f1))"
}

if [[ -z "$INITRAMFS" || ! -e "$INITRAMFS" ]]; then
    build_live_initramfs
fi

# =============================================================================
# 2) squashfs uruchomionego systemu
# =============================================================================
info "buduję squashfs systemu (to trwa)…"
SQUASHFS="$ISODIR/live/filesystem.squashfs"
EXCLUDES="$WORK/excludes"
# UWAGA: mksquashfs z -wildcards NIE akceptuje wykluczeń zaczynających się od
# '/', './' ani '../' — ścieżki są WZGLĘDNE wobec korzenia squashfs.
cat > "$EXCLUDES" <<'EXC'
proc/*
sys/*
dev/*
run/*
tmp/*
var/tmp/*
var/cache/*
var/lib/pagan-sync/cache/*
var/log/*
mnt/*
media/*
swapfile
lost+found
.pag_staging/*
boot/initramfs-*.img
usr/src/kernel
EXC
# PRYWATNOŚĆ: domyślnie NIE dołączamy /home ani /root (dane użytkownika, klucze
# SSH/GPG, profile przeglądarki, historia…). Dla osobistej migawki: --include-home
# albo MKISO_INCLUDE_HOME=1 w /etc/pagan/mkiso.conf.
if [[ "${MKISO_INCLUDE_HOME:-0}" != "1" ]]; then
    printf 'home/*\nroot/*\n' >> "$EXCLUDES"
    info "wykluczam /home i /root (prywatność) — użyj --include-home, by dołączyć"
fi
# Wyklucz katalog roboczy oraz cel ISO (ścieżki względne, bez wiodącego '/').
printf '%s/*\n' "${WORK#/}" >> "$EXCLUDES"
if [[ -n "$MKISO_OUT" ]]; then
    _out_abs="$(readlink -f "$MKISO_OUT" 2>/dev/null || printf '%s' "$MKISO_OUT")"
    [[ "$_out_abs" == /* ]] && printf '%s\n' "${_out_abs#/}" >> "$EXCLUDES"
fi

JOBS="${MKISO_JOBS:-$(nproc)}"
mksquashfs / "$SQUASHFS" -wildcards -ef "$EXCLUDES" -noappend -comp "${MKISO_COMP%% *}" \
    ${MKISO_COMP#"${MKISO_COMP%% *}"} -processors "$JOBS" || die "mksquashfs nie powiódł się"
ok "squashfs: $(du -h "$SQUASHFS" | cut -f1)"

# =============================================================================
# 3) drzewo ISO: jądro + initramfs + loading
# =============================================================================
cp -fL "$KERNEL" "$ISODIR/boot/vmlinuz-linux"
cp -fL "$INITRAMFS" "$ISODIR/boot/initramfs.img"

# =============================================================================
# 4) BIOS (isolinux)
# =============================================================================
ISO_MBR=""
if [[ $MKISO_DO_BIOS -eq 1 ]]; then
    ISO_BIN="$(_find_syslinux isolinux.bin || true)"
    LDLINUX="$(_find_syslinux ldlinux.c32 || true)"
    MBR_BIN="$(_find_syslinux isohdpfx.bin || true)"
    if [[ -n "$ISO_BIN" && -n "$MBR_BIN" ]]; then
        cp -f "$ISO_BIN" "$ISODIR/isolinux/isolinux.bin"
        [[ -n "$LDLINUX" ]] && cp -f "$LDLINUX" "$ISODIR/isolinux/ldlinux.c32"
        for m in libcom32.c32 libutil.c32 menu.c32; do
            mf="$(_find_syslinux "$m" || true)"; [[ -n "$mf" ]] && cp -f "$mf" "$ISODIR/isolinux/$m"
        done
        cat > "$ISODIR/isolinux/isolinux.cfg" <<EOF
DEFAULT pagan
TIMEOUT 100
PROMPT 0

LABEL pagan
    MENU LABEL ^Pagan Linux Live
    KERNEL /boot/vmlinuz-linux
    APPEND initrd=/boot/initramfs.img pagan.live rw quiet splash

LABEL pagan-fallback
    MENU LABEL Pagan Linux (tryb awaryjny)
    KERNEL /boot/vmlinuz-linux
    APPEND initrd=/boot/initramfs.img pagan.live rw noacpi nomodeset

LABEL pagan-debug
    MENU LABEL Pagan Linux (debug – powłoka)
    KERNEL /boot/vmlinuz-linux
    APPEND initrd=/boot/initramfs.img pagan.live break
EOF
        ISO_MBR="$MBR_BIN"
    else
        warn "brak isolinux.bin/isohdpfx.bin – pomijam boot BIOS"
    fi
fi

# =============================================================================
# 5) UEFI (GRUB) — efiboot.img
# =============================================================================
EFI_IMG=""
if [[ $MKISO_DO_UEFI -eq 1 ]]; then
    if [[ -d /usr/lib/grub/x86_64-efi ]] && _have grub-mkstandalone && _have mkfs.fat && _have mcopy; then
        info "buduję EFI (GRUB standalone)..."
        mkdir -p "$ISODIR/boot/grub" "$WORK/efi/EFI/BOOT"
        cat > "$WORK/grub-efi.cfg" <<'GEOF'
set default=0
set timeout=10
menuentry "Pagan Linux (LIVE)" {
    linux /boot/vmlinuz-linux pagan.live rw quiet splash
    initrd /boot/initramfs.img
}
menuentry "Pagan Linux (verbose)" {
    linux /boot/vmlinuz-linux pagan.live rw
    initrd /boot/initramfs.img
}
GEOF
        if grub-mkstandalone -O x86_64-efi -o "$WORK/efi/EFI/BOOT/BOOTX64.EFI" \
               --modules="iso9660 part_gpt part_msdos normal linux echo" \
               "boot/grub/grub.cfg=$WORK/grub-efi.cfg" >/dev/null 2>&1; then
            dd if=/dev/zero of="$WORK/efi.img" bs=1M count=8 status=none
            mkfs.fat -F12 "$WORK/efi.img" >/dev/null 2>&1
            mcopy -s -i "$WORK/efi.img" "$WORK/efi/EFI" ::/ 2>/dev/null || mcopy -s -i "$WORK/efi.img" "$WORK/efi/EFI" ::
            EFI_IMG="$WORK/efi.img"
        else
            warn "grub-mkstandalone nie powiódł się – pomijam UEFI"
        fi
    else
        warn "brak narzędzi GRUB/EFI (grub-mkstandalone, mkfs.fat, mtools) – pomijam boot UEFI"
    fi
fi

# =============================================================================
# 6) xorriso — hybrydowe ISO
# =============================================================================
info "buduję ISO (xorriso)…"
XORRISO_ARGS=(-as mkisofs -iso-level 3 -full-iso9660-filenames -joliet -joliet-long
    -rational-rock -volid "$MKISO_LABEL")
if [[ -n "$ISO_MBR" ]]; then
    XORRISO_ARGS+=(-eltorito-boot isolinux/isolinux.bin -no-emul-boot -boot-load-size 4
        -boot-info-table -isohybrid-mbr "$ISO_MBR")
fi
if [[ -n "$EFI_IMG" ]]; then
    cp -f "$EFI_IMG" "$ISODIR/boot/efiboot.img"
    XORRISO_ARGS+=(-eltorito-alt-boot -e boot/efiboot.img -no-emul-boot -isohybrid-gpt-basdat)
fi
XORRISO_ARGS+=(-o "$MKISO_OUT" "$ISODIR")

xorriso "${XORRISO_ARGS[@]}" >/dev/null 2>&1 || die "xorriso nie powiódł się"
[[ -s "$MKISO_OUT" ]] || die "ISO nie powstało"

ok "ISO gotowe: $MKISO_OUT ($(du -h "$MKISO_OUT" | cut -f1))"
[[ -n "$ISO_MBR" ]] && info "  boot: BIOS (isolinux) hybrydowy"
[[ -n "$EFI_IMG" ]] && info "  boot: UEFI (GRUB)"
info "  Wypal/wgraj: sudo dd if='$MKISO_OUT' of=/dev/sdX bs=4M status=progress oflag=sync"
exit 0
