#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║                    PAG - Pagan Linux Package Manager v4.2.2                  ║
║         Produkcyjny menedżer pakietów – atomowy, bezpieczny, i18n            ║
╚══════════════════════════════════════════════════════════════════════════════╝

KLUCZOWE CECHY:
  - Transakcja grupowa: staging CAŁEJ grupy → commit (błąd paczki nie psuje systemu)
  - Snapshoty btrfs przed transakcją + wpisy GRUB (rollback przy starcie)
  - Atomowa instalacja przez staging (tmpdir → rename) – brak pół-instalacji
  - Bezpieczne usuwanie – sprawdza czy plik nie jest współdzielony
  - SQLite dla bazy plików – miliony plików bez problemu
  - GPG: weryfikacja repo.json + podpisy pakietów + pinning fingerprintu
  - Hooki: pre/post-install, pre/post-remove (piaskownica env, timeout, audit)
  - Głęboka weryfikacja SHA256 per-plik
  - Pełny rollback – cofa fizyczne pliki
  - Blokada flock – tylko jedna instancja
  - Transakcje z migawkami + rejestr wykonanych hooków
  - Cache HTTP (ETag/If-Modified-Since)
  - Wielojęzyczność (i18n) – PL, EN

FORMAT PAKIETU (.pag):
  ├── data.tar.xz        – pliki + sums.json (SHA256 per plik)
  ├── metadata.json      – nazwa, wersja, zależności
  └── hooks/             – pre-install, post-install, pre-remove, post-remove

MODEL ZAUFANIA / BEZPIECZEŃSTWO:
  - Repozytorium MUSI być zaufane: podpisy GPG zweryfikowane; fingerprint
    klucza przypiętego do repo (TOFU przy pierwszym użyciu, potem pinning).
  - Hooki uruchamiają dowolny plik z pakietu jako ROOT (jak apt/pacman).
    Ograniczamy je (czyste env, timeout, PAG_NO_HOOKS=1, log do
    /var/log/pag/audit.log) i rejestrujemy w transakcji, ale ostatecznie
    instalujesz kod, któremu ufasz.
  - self-update: weryfikacja podpisu + SHA256 + składnia, atomowa podmiana.
"""

import os, sys, json, copy, shutil, hashlib, tarfile, tempfile, subprocess, time, fcntl, locale, re, difflib

def _early(en, pl):
    return pl if os.environ.get("LANG", "")[:2] == "pl" else en

# Twarde moduły Pythona. Zamiast tracebacku dajemy jasny komunikat, bo brak
# tych modułów oznacza zwykle niezadeklarowaną zależność pakietu (sqlite/xz).
try:
    import sqlite3
except ImportError:
    sys.stderr.write(_early("pag: Python without sqlite3 module – install the sqlite "
                            "package (libsqlite3) and rebuild python.\n",
                            "pag: Python bez modułu sqlite3 – zainstaluj pakiet sqlite "
                            "(libsqlite3) i przebuduj python.\n"))
    sys.exit(1)
try:
    import lzma  # noqa: F401 – potrzebny do paczek .pag (XZ)
except ImportError:
    sys.stderr.write(_early("pag: Python without lzma module – install the xz "
                            "package (liblzma) and rebuild python.\n",
                            "pag: Python bez modułu lzma – zainstaluj pakiet xz "
                            "(liblzma) i przebuduj python.\n"))
    sys.exit(1)

# Fix TLS trust inside the Pagan chroot: point Python at the CA bundle that
# pag ships, otherwise urlopen() fails with "unable to get local issuer
# certificate" (no default capath/cafile is resolved in the chroot).
for _cafile in (
    "/etc/ssl/certs/ca-certificates.crt",
    "/etc/ssl/cert.pem",
):
    if os.path.isfile(_cafile):
        os.environ["SSL_CERT_FILE"] = _cafile
        break

from pathlib import Path
from datetime import datetime, timezone
from typing import Dict, List, Optional, Tuple, Set
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.request import urlopen, Request
import threading, itertools
import uuid  # serialNumber SBOM (CycloneDX)

# Wersja klienta – do porównania z repo.json["pag_version"] (self-update)
PAG_VERSION = "4.3.0"
from urllib.error import URLError, HTTPError

# =============================================================================
# Pagan progress — animowany pasek „Drakkar” (własny motyw Pagan/Loki)
# -----------------------------------------------------------------------------
# Zamiast statycznego „█” pasek jest animowany: łódź wikingów płynie po
# falującym morzu, a za nią ciągnie się smuga z wędrującym refleksem. Animacja
# jest funkcją czasu, więc „płynie” nawet gdy postęp stoi w miejscu (długa
# instalacja jednego pakietu, przerwa między fragmentami pobierania).
#
# Konfiguracja (zmienne środowiskowe):
#   PAG_NO_ANIM=1         – wyłącz animację (zostaje klasyczny statyczny pasek)
#   PAG_BAR_STYLE=<styl>  – drakkar (domyślnie) | snake | classic
# Poza TTY animacja jest automatycznie wyłączona (czyste logi w plikach).
# =============================================================================

_PAGAN_ANIM = os.environ.get("PAG_NO_ANIM", "") not in ("1", "true", "yes", "on")
_PAGAN_STYLE = os.environ.get("PAG_BAR_STYLE", "drakkar").strip().lower()
_DRAW_LOCK = threading.Lock()          # serializacja zapisów wielu pasków

# Dwie fazy fali – przesuwane w czasie dają wrażenie ruchu morza.
_WAVE_PHASES = ("~_", "_~")

# Zapas kolumn przy rysowaniu paska: ostatnia kolumna terminala wywołuje
# „auto-wrap”, a glify szerokie (np. emoji 📦) liczą się jako 1 w `len()`, ale
# zajmują 2 kolumny – margines chroni przed zawinięciem linii.
_BAR_MARGIN = 2


def _term_width(stream=None, default: int = 80) -> int:
    """Szerokość terminala (w kolumnach) dla strumienia paska.

    Pasek MUSI zmieścić się w jednej linii: gdy jest szerszy niż terminal, ten
    sam go zawija i KAŻDA aktualizacja trafia do nowej linii zamiast nadpisywać
    poprzednią. Pytamy o rozmiar konkretnego `stream` (pasek pisze na stderr),
    a nie domyślnego stdout – inaczej przy przekierowanym stdout dostalibyśmy
    fałszywe 80 kolumn.
    """
    fd = None
    if stream is not None:
        try:
            fd = stream.fileno()
        except Exception:
            fd = None
    if fd is not None:
        try:
            cols = os.get_terminal_size(fd).columns
            if cols > 0:
                return cols
        except OSError:
            pass
    try:
        cols = shutil.get_terminal_size((default, 24)).columns
    except Exception:
        cols = default
    return cols if cols > 0 else default


def _classic_bar(pct: float, width: int) -> str:
    """Klasyczny statyczny pasek █/░ (fallback dla logów i PAG_NO_ANIM)."""
    filled = int(round(width * max(0.0, min(100.0, pct)) / 100.0))
    return "█" * filled + "░" * (width - filled)


def _fmt_size(n: float) -> str:
    """Rozmiar w czytelnych jednostkach (1.2 MB, 345.6 KB)."""
    for unit in ("B", "KB", "MB", "GB"):
        if n < 1024:
            return f"{n:.1f} {unit}"
        n /= 1024
    return f"{n:.1f} TB"


def _fmt_eta(seconds: float) -> str:
    """Czas pozostały w zwięzłej formie: 8s, 1.4m, 2.1h."""
    if seconds < 60:
        return f"{seconds:.0f}s"
    if seconds < 3600:
        return f"{seconds / 60:.1f}m"
    return f"{seconds / 3600:.1f}h"


def _shrink_text(text: str, room: int) -> str:
    """Skróć `text` do `room` kolumn (wielokropek na końcu)."""
    if room <= 0:
        return ""
    if len(text) <= room:
        return text
    return "…" if room == 1 else text[:room - 1] + "…"


def _fit_widget_line(line: str, stream) -> str:
    """Przytnij linię panelu do szerokości terminala (bez zawijania).

    Zawinięta linia rozjeżdża wielolinijkowy panel: kolejne odświeżenia
    trafiają do nowych wierszy zamiast nadpisywać poprzednie.
    """
    cap = _term_width(stream) - _BAR_MARGIN
    if cap <= 0 or len(line) <= cap:
        return line
    keep = cap - 1
    head = (keep + 1) // 2
    tail = keep - head
    return line[:head] + "…" + (line[-tail:] if tail > 0 else "")


def _drakkar_bar(pct: float, width: int, t: float, filled: int) -> str:
    """Drakkar (łódź wikingów) płynący po falującym morzu.

    - przed łodzią: falujące morze (~ _ przesuwane w czasie),
    - dziób łodzi: » (kolumna = bieżący postęp),
    - za łodzią: smuga z wędrującym refleksem światła.
    """
    done = pct >= 100.0
    wave = _WAVE_PHASES[int(t * 6) % len(_WAVE_PHASES)]
    ship = min(filled, width - 1)
    glow = int(t * 10) % ship if ship > 0 else -1
    out = []
    for i in range(width):
        if done:
            out.append("»" if i == width - 1 else "█")   # łódź zacumowana
        elif i < ship:
            out.append("█" if i == glow else "▓")
        elif i == ship:
            out.append("»")
        else:
            out.append(wave[i & 1])
    return "".join(out)


def _snake_bar(pct: float, width: int, t: float, filled: int) -> str:
    """Jörmungandr – wąż sunący przez pasek (głowa @, łuski o/~, ogon ·)."""
    done = pct >= 100.0
    head = min(filled, width - 1)
    out = []
    for i in range(width):
        if done:
            out.append("@" if i == width - 1 else "o")
        elif i < head:
            out.append("o" if (i + int(t * 6)) & 1 else "~")
        elif i == head:
            out.append("@")
        else:
            out.append("·")
    return "".join(out)


def _pagan_bar(pct: float, width: int = 30, t: float = 0.0,
               style: Optional[str] = None, animated: bool = True) -> str:
    """Zwraca jednoliniowy pasek postępu o STAŁEJ szerokości `width`.

    `pct`      – postęp 0..100
    `t`        – czas (s); różne `t` → inna klatka animacji
    `animated` – False wymusza klasyczny statyczny pasek (np. brak TTY)
    """
    width = max(6, int(width))
    pct = max(0.0, min(100.0, float(pct)))
    style = style or _PAGAN_STYLE
    if not animated or not _PAGAN_ANIM or style == "classic":
        return _classic_bar(pct, width)
    filled = int(round(width * pct / 100.0))
    if style == "snake":
        return _snake_bar(pct, width, t, filled)
    return _drakkar_bar(pct, width, t, filled)


class _Bar:
    """Baza animowanych pasków: rysują JEDNĄ nadpisywaną linię na `stream`.

    Gdy mamy TTY, wątek w tle odświeża pasek ~10×/s, dzięki czemu morze faluje
    także wtedy, gdy postęp chwilowo się nie zmienia.
    """
    def __init__(self, width: int, stream=None):
        self.width = width
        self.stream = stream if stream is not None else sys.stderr
        self.tty = self.stream.isatty()
        self._lock = threading.RLock()
        self._last_len = 0
        self._stop = threading.Event()
        self._thread = None

    # -- wątek animacji -------------------------------------------------------
    def _start_anim(self):
        if _PAGAN_ANIM and self.tty and self._thread is None:
            self._thread = threading.Thread(target=self._anim_loop, daemon=True)
            self._thread.start()

    def _anim_loop(self):
        while not self._stop.wait(0.1):
            with self._lock:
                if self._stop.is_set():
                    break
                self._write(self._line())

    def _stop_anim(self):
        self._stop.set()
        if self._thread is not None:
            self._thread.join(timeout=0.3)
            self._thread = None

    # -- rysowanie ------------------------------------------------------------
    def _cap(self) -> int:
        """Maksymalna liczba kolumn jednej linii paska (z zapasem na wrap)."""
        return _term_width(self.stream) - _BAR_MARGIN

    def _shrink(self, text: str, fixed: int) -> str:
        """Skróć `text` tak, by `text` + `fixed` kolumn zmieściło się w linii."""
        room = self._cap() - fixed
        if room >= 1 and len(text) > room:
            return "…" if room == 1 else text[:room - 1] + "…"
        return text

    def _fit(self, line: str) -> str:
        """Ostatnia linia obrony: przytnij linię do szerokości terminala.

        Wycinamy ŚRODEK (wielokropek), więc widoczne zostają początek (nazwa)
        i koniec (%, prędkość, ETA). Bez tego zawinięta linia = nowa linia przy
        każdym odświeżeniu zamiast nadpisywania poprzedniej.
        """
        cap = self._cap()
        if cap <= 0 or len(line) <= cap:
            return line
        keep = cap - 1                       # miejsce na wielokropek „…”
        head = (keep + 1) // 2
        tail = keep - head
        return line[:head] + "…" + (line[-tail:] if tail > 0 else "")

    def _write(self, line: str):
        line = self._fit(line)
        clear = " " * max(0, self._last_len - len(line))
        with _DRAW_LOCK:
            self.stream.write(f"\r{line}{clear}")
            self.stream.flush()
        self._last_len = len(line)

    def _line(self) -> str:
        raise NotImplementedError

    def _clear_line(self):
        if self.tty and self._last_len:
            with _DRAW_LOCK:
                self.stream.write("\r" + " " * self._last_len + "\r")
                self.stream.flush()
        self._last_len = 0

    def _newline(self):
        if self.tty and self._last_len:
            self.stream.write("\n")
            self.stream.flush()
        self._last_len = 0


class ProgressBar(_Bar):
    """Pasek postępu dla N elementów — animowany („drakkar”) na TTY."""
    def __init__(self, total: int, desc: str = "", unit: str = "", width: int = 30):
        super().__init__(width)
        self.total = max(total, 1)
        self.desc = desc
        self.unit = unit
        self.n = 0
        self.suffix = ""
        self.start = time.time()
        self._start_anim()

    def _line(self) -> str:
        pct = self.n / self.total * 100
        elapsed = time.time() - self.start
        speed = self.n / elapsed if elapsed > 0 else 0
        if self.n >= self.total:
            eta_str = _("done")
        elif speed > 0:
            eta_str = _fmt_eta((self.total - self.n) / speed)
        else:
            eta_str = "?..."
        bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
        tail = f" [{bar}] {self.n}/{self.total} ({pct:.0f}%) ETA {eta_str}{self.suffix}"
        desc = self._shrink(self.desc, 2 + len(tail))
        return f"  {desc}{tail}"

    def update(self, n: Optional[int] = None, suffix: str = ""):
        with self._lock:
            if n is not None:
                self.n = n
            else:
                self.n += 1
            self.suffix = suffix
            if self.tty:
                self._write(self._line())
            elif (self.n == 1 or self.n >= self.total
                  or self.n % max(1, self.total // 10) == 0):
                # Bez TTY – tylko kamienie milowe (czysty log)
                print(self._line(), file=self.stream)

    def close(self):
        self._stop_anim()
        with self._lock:
            self._newline()

    def __enter__(self):
        return self

    def __exit__(self, *args):
        self.close()


class DownloadBar(_Bar):
    """Animowany pasek pobierania (na podstawie Content-Length)."""
    def __init__(self, filename: str, total_bytes: int):
        super().__init__(25)
        self.filename = filename
        self.total = total_bytes
        self.downloaded = 0
        self.start = time.time()
        self._start_anim()

    def _line(self) -> str:
        pct = self.downloaded / self.total * 100 if self.total > 0 else 0.0
        elapsed = time.time() - self.start
        speed = self.downloaded / elapsed if elapsed > 0 else 0
        if self.total > 0 and speed > 0:
            eta_str = _fmt_eta((self.total - self.downloaded) / speed)
        else:
            eta_str = "?..."
        bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
        sz = _fmt_size(self.total)
        spd = _fmt_size(int(speed))
        tail = f" [{bar}] {pct:.0f}% {sz} {spd}/s ETA {eta_str}"
        # Nazwa pliku bywa długa (np. linux-firmware-…-1.pag) i wtedy CAŁA linia
        # nie mieści się w terminalu (zawijanie → nowa linia przy każdym %).
        # Skracamy WYŁĄCZNIE nazwę – pełny pasek, prędkość i ETA zostają.
        name = self._shrink(self.filename, 4 + len(tail))   # prefiks „  ↓ ” = 4 kolumny
        return f"  ↓ {name}{tail}"

    def update(self, chunk_size: int):
        with self._lock:
            self.downloaded += chunk_size
            if self.tty and self.total > 0:
                self._write(self._line())

    def close(self):
        self._stop_anim()
        with self._lock:
            if self.total > 0:
                self._newline()


class _ParallelDownloadDisplay:
    """Panel pobierania równoległego: pasek zbiorczy + linia na każde pobranie.

    Linia pobrania pokazuje procent, a w nawiasie nazwę pakietu, liczbę
    pobranych bajtów i ETA – czyli dokładnie to, czego brakowało przy
    równoległym pobieraniu:

        ⏬ [████»~~~~] 4/12 (33%)
        ↓ [███»~~~~~~]  38% (mesa: 12.3/29.1 MB, ETA 8s)
        ↓ [█████»~~~~]  67% (glibc: 8.8/10.0 MB, ETA 3s)

    Na TTY panel jest rysowany „w miejscu” (ANSI): pasek zbiorczy i aktywne
    pobrania są nadpisywane, a ukończone pobrania zostają wypisane na stałe
    nad panelem. Poza TTY nie ruszamy kursora – log dostaje linię startu,
    kamienie milowe (25/50/75%) i wynik, więc pozostaje czytelny.
    """
    BAR_W = 20
    _POLL = 0.1

    def __init__(self, total: int, stream=None):
        self.stream = stream if stream is not None else sys.stderr
        self.tty = self.stream.isatty()
        self.total = max(1, int(total))
        self.completed = 0
        self._lock = threading.RLock()
        self._slots: Dict[int, dict] = {}
        self._next_id = 0
        self._drawn = 0
        self._stop = threading.Event()
        self._thread = None
        self._cursor_hidden = False
        if self.tty:
            self._emit("\x1b[?25l")       # ukryj kursor na czas panelu
            self._cursor_hidden = True
            self._thread = threading.Thread(target=self._anim_loop, daemon=True)
            self._thread.start()

    # -- rysowanie -----------------------------------------------------------
    def _emit(self, text: str):
        with _DRAW_LOCK:
            self.stream.write(text)
            self.stream.flush()

    def _cap(self) -> int:
        return _term_width(self.stream) - _BAR_MARGIN

    def _clear_panel(self):
        """Wyczyść panel i ustaw kursor na początku jego pierwszej linii."""
        if not self.tty or self._drawn <= 0:
            return
        out = ["\r\x1b[2K"]
        out.extend("\x1b[1A\r\x1b[2K" for _ in range(self._drawn - 1))
        self._emit("".join(out))
        self._drawn = 0

    def _render_locked(self):
        if not self.tty:
            return
        self._clear_panel()
        lines = [self._overall_line()]
        lines.extend(self._slot_line(s) for s in self._slots.values())
        self._emit("\n".join(lines))
        self._drawn = len(lines)

    def _render(self):
        with self._lock:
            self._render_locked()

    def _anim_loop(self):
        while not self._stop.wait(self._POLL):
            self._render()

    def _overall_line(self) -> str:
        pct = self.completed / self.total * 100.0
        bar = _pagan_bar(pct, self.BAR_W, time.time(), animated=self.tty)
        line = f"  ⏬ [{bar}] {self.completed}/{self.total} ({pct:.0f}%)"
        return _fit_widget_line(line, self.stream)

    def _slot_line(self, s: dict) -> str:
        total = int(s.get("total") or 0)
        done = int(s.get("downloaded") or 0)
        pct = (done / total * 100.0) if total > 0 else 0.0
        elapsed = time.time() - s["start"]
        speed = done / elapsed if elapsed > 0 else 0.0
        finished = total > 0 and done >= total
        if finished:
            eta = _("done")
        elif total > 0 and speed > 0:
            eta = _fmt_eta((total - done) / speed)
        else:
            eta = "?…"
        bar = _pagan_bar(pct, self.BAR_W, time.time(), animated=self.tty)
        prefix = f"  ↓ [{bar}] {pct:3.0f}% "
        size = (f"{_fmt_size(done)}/{_fmt_size(total)}" if total > 0
                else _fmt_size(done))
        suffix = (f": {size}, {eta})" if finished
                  else f": {size}, ETA {eta})")
        # Nazwa bywa długa – skracamy TYLKO ją, zostawiając %, rozmiar i ETA.
        room = self._cap() - len(prefix) - 1 - len(suffix)
        name = _shrink_text(s["name"], room)
        return _fit_widget_line(f"{prefix}({name}{suffix}", self.stream)

    # -- API wątków pobierających --------------------------------------------
    def start(self, name: str, expected_size: int = 0) -> int:
        with self._lock:
            sid = self._next_id
            self._next_id += 1
            self._slots[sid] = {
                "name": name,
                "downloaded": 0,
                "total": int(expected_size or 0),
                "start": time.time(),
                "milestone": -1,
            }
            if self.tty:
                self._render_locked()
            else:
                self._emit(f"  ↓ {name}\n")
            return sid

    def progress(self, sid: int, downloaded: int, total: int = 0):
        with self._lock:
            s = self._slots.get(sid)
            if s is None:
                return
            s["downloaded"] = int(downloaded)
            if total and total > 0:
                s["total"] = int(total)
            if self.tty:
                return                    # odświeży wątek animacji
            total = s["total"]
            pct = downloaded / total * 100.0 if total > 0 else 0.0
            step = int(pct // 25) * 25
            if step > s["milestone"]:
                s["milestone"] = step
                if total > 0:
                    detail = f"{_fmt_size(downloaded)}/{_fmt_size(total)}"
                else:
                    detail = _fmt_size(downloaded)
                self._emit(f"  ↓ {s['name']}: {pct:.0f}% ({detail})\n")

    def finish(self, sid: int, ok: bool = True):
        with self._lock:
            s = self._slots.pop(sid, None)
            if s is None:
                return
            self.completed += 1
            line = self._done_line(s, ok)
            if self.tty:
                self._clear_panel()
                self._emit(line + "\n")
                self._render_locked()
            else:
                self._emit(line + "\n")

    def log(self, text: str):
        """Wypisz komunikat (np. ponowienie pobierania) bez psucia panelu."""
        with self._lock:
            if self.tty:
                self._clear_panel()
                self._emit(text + "\n")
                self._render_locked()
            else:
                self._emit(text + "\n")

    def _done_line(self, s: dict, ok: bool) -> str:
        if not ok:
            return f"  ❌ {s['name']}: {_('download_fail')}"
        total = int(s.get("total") or 0)
        size = _fmt_size(total if total > 0 else s.get("downloaded", 0))
        elapsed = _fmt_eta(time.time() - s["start"])
        return _fit_widget_line(f"  ✅ {s['name']} ({size}, {elapsed})",
                                self.stream)

    def close(self):
        self._stop.set()
        if self._thread is not None:
            self._thread.join(timeout=0.3)
            self._thread = None
        with self._lock:
            if self.tty:
                self._clear_panel()
            if self._cursor_hidden:
                self._emit("\x1b[?25h")   # przywróć kursor
                self._cursor_hidden = False


class _StepBar(_Bar):
    """Animowany pasek dla pętli „krok po kroku” (instalacja/aktualizacja).

    Pasek nie skacze skokowo co pakiet – między krokami łagodnie „dopełza”
    w stronę kolejnego progu (jak w instalatorach), więc rośnie w sposób
    ciągły. Wątek animacji odświeża go ~10×/s.
    """
    def __init__(self, total: int, icon: str = "", width: int = 25,
                 creep_tau: float = 3.0):
        super().__init__(width)
        self.total = max(total, 1)
        self.icon = icon
        self.creep_tau = creep_tau      # „stała czasu” dopełzania (s)
        self.idx = 0
        self.label = ""
        self.t0 = time.time()
        self._step_t = time.time()      # start bieżącego pakietu
        self._start_anim()

    def _frac(self) -> float:
        """Ukończona część [0..1]: kroki + wygładzone dopełzanie w bieżącym."""
        done = max(0, self.idx - 1)
        if done >= self.total:
            return 1.0
        # 0.5 ** (dt/tau): 0 → ~1 asymptotycznie; cap 0.9, by krok był widoczny
        creep = 1.0 - 0.5 ** ((time.time() - self._step_t) / self.creep_tau)
        return (done + min(creep, 0.9)) / self.total

    def _line(self) -> str:
        pct = self._frac() * 100.0
        eta_s = ""
        if self.idx > 1:
            avg = (time.time() - self.t0) / (self.idx - 1)
            rem = avg * (self.total - self.idx + 1)
            eta_s = f" ~{rem:.0f}s" if rem < 60 else f" ~{rem/60:.1f}m"
        bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
        tail = f"[{bar}] {self.idx}/{self.total} ({pct:.0f}%) "
        label = self._shrink(self.label, 2 + len(self.icon) + len(tail) + len(eta_s))
        return f"  {self.icon}{tail}{label}{eta_s}"

    def step(self, idx: int, label: str):
        with self._lock:
            self.idx = idx
            self.label = label
            self._step_t = time.time()
            if self.tty:
                self._write(self._line())
            else:
                print(self._line(), file=self.stream)

    def end(self):
        self._stop_anim()
        with self._lock:
            self._clear_line()

# =============================================================================
# GPG – BEZPIECZNE WYWOŁYWANIE (odporne na brak binarki gpg)
# =============================================================================

GPG_BINARY = shutil.which("gpg2") or shutil.which("gpg") or "gpg"
GPG_HOME = "/etc/pag/gpg"  # izolowany keyring (działa z keyboxd GPG 2.4+)

def _ssl_ok() -> bool:
    """Czy Python ma działający moduł ssl (HTTPS w urllib).

    Bez niego urllib nie zna schematu https i każda operacja sieciowa kończy
    się „unknown url type: https” – myląco, bo wygląda jak błąd adresu.
    """
    try:
        import ssl  # noqa: F401
        return True
    except Exception:
        return False


def _gpg_run(*args, timeout: int = 30, **kwargs) -> subprocess.CompletedProcess:
    """
    Bezpieczne wywołanie GPG – przechwytuje FileNotFoundError,
    gdyby gpg/gpg2 nie było zainstalowane w minimalnym środowisku.
    Wymusza LC_ALL=C aby komunikaty GPG były zawsze po angielsku
    (niezależnie od locale systemu) – kluczowe dla parsowania stderr.
    """
    env = kwargs.pop("env", None) or os.environ.copy()
    env["LC_ALL"] = "C"
    env["GNUPGHOME"] = GPG_HOME
    _text = bool(kwargs.get("text") or kwargs.get("universal_newlines"))
    try:
        return subprocess.run([GPG_BINARY, *args], timeout=timeout, env=env, **kwargs)
    except FileNotFoundError:
        # GPG nie jest dostępne – zwróć błąd z komunikatem
        # (szanuj text=True – inaczej caller dostaje bytes i może wybuchnąć TypeError)
        _text = bool(kwargs.get("text") or kwargs.get("universal_newlines"))
        _msg = _("gpg_binary_not_found", GPG_BINARY)
        return subprocess.CompletedProcess(
            [GPG_BINARY, *args], 127,
            stdout=("" if _text else b""),
            stderr=(_msg if _text else _msg.encode()),
        )
    except subprocess.TimeoutExpired:
        _msg = _("gpg_timeout")
        return subprocess.CompletedProcess(
            [GPG_BINARY, *args], 124,
            stdout=("" if _text else b""),
            stderr=(_msg if _text else _msg.encode())
        )

def _load_trust_db() -> dict:
    """Mapa repo_url → fingerprint klucza podpisującego (baza zaufania)."""
    try:
        with open(TRUST_DB) as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return {}


def _save_trust_db(db: dict):
    os.makedirs(os.path.dirname(TRUST_DB), exist_ok=True)
    with open(TRUST_DB, "w") as f:
        json.dump(db, f, indent=2)


def _gpg_verify_fp(sig_path: str, data_path: str, timeout: int = 30):
    """Weryfikuje podpis i odczytuje fingerprint podpisującego.

    Używa --status-fd=1 i linii VALIDSIG <fingerprint>. Zwraca (ok, fingerprint).

    FAIL-CLOSED: OK tylko gdy GPG zwrócił 0 ORAZ w statusie maszynowym jest
    linia VALIDSIG. Nie zakładamy sukcesu na podstawie samego kodu wyjścia –
    gdyby format --status-fd się zmienił, wolimy odrzucić podpis niż przyjąć
    niezaufany pakiet (wywołujący traktuje fp=None jako brak potwierdzenia).
    """
    env = os.environ.copy()
    res = _gpg_run("--verify", "--status-fd", "1", sig_path, data_path,
                   capture_output=True, text=True, timeout=timeout, env=env)
    out = res.stdout or ""
    m = re.search(r"\[GNUPG:\]\s+VALIDSIG\s+([0-9A-Fa-f]{16,})", out)
    if not m:
        m = re.search(r"\bVALIDSIG\s+([0-9A-Fa-f]{16,})", out)
    if res.returncode != 0 or not m:
        return False, None
    return True, m.group(1).upper()


def _verify_local_pkg_signature(pkg_path: str) -> bool:
    """Weryfikuje lokalny .pag tym samym kluczem co zaufane repo."""
    # PAG_INSECURE=1 – spójnie z _verify_repo_sig() i _verify_pkg_signature().
    # Potrzebne w środowisku BUILDA: instalator buduje własne .pag (np. `kernel`)
    # lokalnie, nie ma dla nich pliku .asc, a klucza prywatnego repo celowo NIE ma
    # na maszynie budującej. Wcześniej ta funkcja jako jedyna ignorowała
    # PAG_INSECURE, więc obejście używane przez resztę builda tu nie działało.
    if os.environ.get("PAG_INSECURE", "") == "1":
        print(_('  ⚠ PAG_INSECURE=1 – skipping local package signature verification'))
        return True
    sig_path = next((pkg_path + ext for ext in (".asc", ".sig")
                     if os.path.isfile(pkg_path + ext)), "")
    if not sig_path:
        print(_('  ❌ No signature for package: {arg1}', arg1=(pkg_path)))
        print(_('     A .pag.asc/.pag.sig file from the same source is required.'))
        return False
    ok, fingerprint = _gpg_verify_fp(sig_path, pkg_path)
    if not ok or not fingerprint:
        print(_('  ❌ Invalid package signature: {arg1}', arg1=(pkg_path)))
        return False
    expected = _repo_pinned_fp(DEFAULT_REPOS[0])
    if not expected:
        print(_('  ❌ No pinned repo key for the local package.'))
        print(_('     Run first: sudo pag sync'))
        return False
    if fingerprint != expected.upper():
        print(_('  ❌ [SECURITY ERROR] Package was signed with a different repo key.'))
        print(_('     Expected: {arg1}', arg1=(expected)))
        print(_('     Received:  {arg1}', arg1=(fingerprint)))
        return False
    print(_('  🔐 Package signature OK ({arg1})', arg1=(fingerprint)))
    return True


# =============================================================================
# i18n – WIELOJĘZYCZNOŚĆ
# =============================================================================

LANG = os.environ.get("LANG", "en_US.UTF-8")[:2]  # pl, en, de...
COLOR = os.environ.get("NO_COLOR", "") == "" and sys.stdout.isatty()

def _c(code: str, text: str) -> str:
    """Dodaje kody ANSI jeśli kolor jest włączony."""
    if not COLOR:
        return text
    colors = {
        "green": "\033[32m", "red": "\033[31m", "yellow": "\033[33m",
        "cyan": "\033[36m", "bold": "\033[1m", "dim": "\033[2m",
        "reset": "\033[0m",
    }
    return f"{colors.get(code,'')}{text}{colors['reset']}"

T = {
    "en": {
        "root_required": "pag requires root privileges (sudo).",
        "db_locked": "Another pag instance is running.",
        "db_lock_hint": "If no other pag process is running, wait a moment and retry.",
        "no_index": "Cannot fetch repository indexes. Run 'pag update'.",
        "cache_ro": "Repo cache is read-only ({cache}) – using local index (may be outdated).\n     Refresh as root: sudo pag sync",
        "all_installed": "All packages are already installed.",
        "to_install": "To install: {} packages ({:.2f} MB)",
        "new": "NEW",
        "continue_q": "Continue? [Y/n] ",
        "no_tty": "No TTY / stdin closed (EOF) – cancelling.",
        "cancelled": "Cancelled.",
        "not_found": "not found in repos",
        "pkg_not_found": "Package not found: {} (not in any repo)",
        "not_found_hint": "Check the spelling or run 'pag search <query>'.",
        "downloading": "Downloading",
        "done": "done",
        "wroom_terminal": "PAG WROOM needs an interactive terminal – run: pag wroom",
        "wroom_too_small": "Enlarge the terminal (min. {arg1}x{arg2})",
        "wroom_tagline": "PAGAN RACING 4.2.2  ·  38911 BYTES FREE",
        "wroom_controls": "←/→ lane   ↑/↓ gas/brake   P pause   Q quit",
        "wroom_press": "PRESS SPACE TO RACE",
        "wroom_over": "RACE OVER",
        "wroom_score": "Score: {arg1}",
        "wroom_best": "Best: {arg1}",
        "wroom_restart": "R / SPACE – race again      Q – quit",
        "wroom_paused": "PAUSED",
        "wroom_hud": "SCORE {arg1:06d}   SPEED {arg2:3d} km/h   LIVES {arg3}",
        "download_fail": "download failed",
        "gpg_fail": "GPG verification failed",
        "sha256_mismatch": "SHA256 mismatch",
        "install_failed": "installation failed",
        "installed": "Installed {} packages.",
        "rollback_restored": "Restored previous state from snapshot.",
        "rollback_files": "Rolled back {} files.",
        "no_history": "No transaction history.",
        "pinned_list": "Pinned packages ({}):",
        "no_pinned": "No pinned packages.",
        "pinned_to": "pinned to",
        "unpinned": "unpinned.",
        "not_pinned": "was not pinned.",
        "repo_added": "Added repository: {}",
        "repo_exists": "Repository already exists: {}",
        "updated_done": "Index refresh complete. {} packages cached.",
        "indexes_refreshed": "Indexes refreshed.",
        "updates_available": "⚠ {} packages have updates – run: pag update",
        "upgrading": "Upgrading: {} packages",
        "all_up_to_date": "All packages are up to date.",
        "removing": "Removing",
        "orphans_found": "Orphaned dependencies ({}): {}",
        "flatpak_missing": "Flatpak is not installed.",
        "flatpak_adding": "Adding Flathub remote...",
        "flatpak_searching": "Searching Flathub for '{}'...",
        "flatpak_found": "Found {} results:",
        "flatpak_not_found": "not found on Flathub",
        "flatpak_install_prompt": "Install {}? [Y/n] ",
        "flatpak_installing": "Installing {}...",
        "flatpak_installed": "Flatpak {} installed.",
        "flatpak_removed": "Flatpak {} removed.",
        "flatpak_not_installed": "Flatpak {} is not installed.",
        "flatpak_info_id": "ID",
        "flatpak_info_version": "Version",
        "flatpak_info_branch": "Branch",
        "flatpak_info_origin": "Origin",
        "flatpak_info_size": "Installed size",
        "flatpak_info_desc": "Description",
        "flatpak_updated": "Flatpaks updated.",
        "flatpak_update_failed": "Flatpak update failed (details above).",
        "flatpak_usage": "Usage: pag flatpak <search|install|remove|list|update|info> [args]",
        "flatpak_scope": "Installation",
        "flatpak_menu_hint": "Installed and verified, but this session may not show it in the menu: Flatpak exports are missing from XDG_DATA_DIRS.",
        "flatpak_menu_fix": "Add /var/lib/flatpak/exports/share to XDG_DATA_DIRS (and .../exports/bin to PATH) in your session, then re-login – PaganDE does this in session/pagande-session.",
        "key_imported": "Key imported successfully.",
        "key_removed": "Key removed: {}",
        "no_keys": "No trusted GPG keys.",
        "gpg_missing": "GNUPG MISSING – install gnupg and retry",
        "ssl_broken": "Python has no working ssl module (HTTPS impossible) – fix the python/openssl packages (e.g. sudo pag install -f python).",
        "key_add_failed": "Key import failed (gpg error) – key was NOT added.",
        "verify_ok": "All {} files intact.",
        "verify_errors": "{} problems found:",
        "cache_cleared": "{} files ({:.2f} MB) cleared from cache.",
        "deployments_list": "Deployments ({}):",
        "no_deployments": "No deployments.",
        "active_deployment": "ACTIVE",
        "deploy_rollback_ok": "Switched to deployment: {}",
        "deploy_rollback_fail": "No previous deployment.",
        "deploy_cleanup_ok": "Removed {} old deployments.",
        "deploy_cleanup_none": "No deployments to clean (minimum {}).",
        "snapshot_none": "No system snapshots.",
        "snapshot_list": "System snapshots ({}):",
        "snapshot_created": "Snapshot created: {}.",
        "snapshot_deleted": "Snapshot removed: {}.",
        "snapshot_not_found": "Snapshot not found: {}",
        "snapshot_unsupported": "Snapshots unavailable: {}",
        "snapshot_rollback_next": "Next boot set to snapshot: {}",
        "snapshot_rollback_hint": "Select this entry in the GRUB menu: {}",
        "staging_prepare": "Preparing {} packages in staging (system unchanged)...",
        "staging_failed": "Staging failed – the system was NOT modified.",
        "staging_commit": "All packages prepared – applying changes...",
        "grub_refreshed": "GRUB menu refreshed.",
        "grub_failed": "GRUB: {}",
        "grub_no_initrd": "GRUB: boot entry has no initramfs – check /boot/initramfs-*.img",
        "crlf_fixed": "{}: CRLF removed (it broke grub-mkconfig).",
        "initramfs_links_fixed": "initramfs symlinks repaired.",
        "no_user_sessions": "no active user sessions – user units load at next login.",
        "dry_run_done": "Dry run – nothing was changed.",
        "dry_run_plan": "Dry run – transaction plan (no changes):",
        "why_explicit": "explicitly installed",
        "why_dependency": "dependency of",
        "why_not_installed": "not installed",
        "rdepends_title": "Reverse dependencies of {} ({}):",
        "rdepends_none": "nothing depends on it.",
        "optional_deps": "Optional dependencies (not installed automatically):",
        "autoremove_ok": "Removed {} orphaned packages.",
        "autoremove_none": "No orphaned packages.",
        "downloaded": "Downloaded {} to cache ({:.2f} MB).",
        "provides_mapped": "{} → {} (provides)",
        "stats_title": "PAG Statistics",
        "stats_packages": "Installed packages",
        "stats_files": "Tracked files",
        "stats_size": "Total size",
        "stats_cache": "Cache size",
        "stats_history": "Transactions",
        "stats_last_update": "Last update",
        # Komunikaty bezpieczeństwa (baza EN; PL w tabeli "pl" jako sec_*_pl)
        "sec_downgrade": "Downgrade blocked: {pkg} {new} < {old}",
        "sec_suid": "SUID stripped from {path}",
        "sec_https": "HTTPS required for repos",
        "sec_badname": "Invalid package name: {name}",
        "sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
        "sec_conflict": "File conflict: {path} owned by {owner}",
        "sec_audit": "{pkg} installed by {user}",
        "sec_locked": "Another pag process is running",
        # Konfiguracja (/etc) – zachowanie zmian użytkownika
        "conf_pacnew": "Modified config kept; new version saved as {path}",
        "conf_pacsave": "Modified config kept as {path}",
        # Zależności wirtualne (provides)
        "provides_conflict": "Multiple providers for '{name}' ({providers}) – using '{chosen}'",

        # Base baked into the ISO image (pag base / base adopt)
        "base_title": "Base from the ISO image",
        "base_no_manifest": "This system carries no base manifest (/usr/share/pag/base.json) – nothing to adopt.",
        "base_iso_version": "Image version",
        "base_total": "Base packages (from image)",
        "base_tracked": "Managed by pag",
        "base_adoptable": "Adoptable from repo",
        "base_unmatched": "No counterpart in repo",
        "base_adopt_hint": "Adopt them (image files get replaced by repo packages): sudo pag base adopt",
        "base_unmatched_hint": "These stay at the image version (no such package in repo):",
        "base_more": "more",
        "base_nothing_selected": "None of the given names is on the adopt list.",
        "base_all_managed": "Every base package is already managed by pag.",
        "base_adopt_plan": "Adopting {} base packages from the repo (~{:.0f} MB):",
        "base_dry_run": "Dry run – nothing was installed.",
        "base_unmanaged_hint": "{} packages from the ISO image are not managed by pag yet – 'sudo pag base adopt' replaces them with repo packages (only then does 'pag upgrade' update them).",
        "base_overwrite": "{} comes from the ISO image – its files will be replaced (backup kept for 'pag rollback').",
        "base_reboot_hint": "Base adopted from the repo – reboot before using the new libraries/toolchain.",
        "base_register_ok": "Registered {} base packages in the package DB ({} were already tracked).",
        "base_register_plan": "Dry run – would register {} base packages.",
        "base_register_nocache": "No cached repo index – builder names kept as-is (run 'sudo pag sync' and 'pag base register' again to map them to repo names).",
        "base_register_renamed": "{} names were matched to their repo package names.",
        "stats_base": "Base (image) managed",
    },
    "pl": {
        "root_required": "pag wymaga uprawnień root (sudo).",
        "db_locked": "Inna instancja pag jest uruchomiona.",
        "db_lock_hint": "Jeśli żaden inny proces pag nie działa, poczekaj chwilę i spróbuj ponownie.",
        "no_index": "Nie można pobrać indeksów repozytoriów. Uruchom 'pag update'.",
        "cache_ro": "Cache repozytoriów jest tylko-do-odczytu ({cache}) – używam lokalnego indeksu (może być nieaktualny).\n     Odśwież jako root: sudo pag sync",
        "all_installed": "Wszystkie pakiety są już zainstalowane.",
        "to_install": "Do zainstalowania: {} pakietów ({:.2f} MB)",
        "new": "NOWY",
        "continue_q": "Kontynuować? [T/n] ",
        "no_tty": "Brak terminala (EOF) – anuluję.",
        "cancelled": "Anulowano.",
        "not_found": "brak w repozytoriach",
        "pkg_not_found": "Nie znaleziono pakietu: {} (brak w repozytoriach)",
        "not_found_hint": "Sprawdź pisownię lub uruchom 'pag search <fraza>'.",
        "downloading": "Pobieranie",
        "done": "gotowe",
        "wroom_terminal": "PAG WROOM wymaga terminala – uruchom: pag wroom",
        "wroom_too_small": "Powiększ terminal (min. {arg1}x{arg2})",
        "wroom_tagline": "PAGAN RACING 4.2.2  ·  38911 BAJTÓW WOLNE",
        "wroom_controls": "←/→ pas   ↑/↓ gaz/hamulec   P pauza   Q wyjście",
        "wroom_press": "NACIŚNIJ SPACJĘ, ABY RUSZYĆ",
        "wroom_over": "KONIEC WYŚCIGU",
        "wroom_score": "Wynik: {arg1}",
        "wroom_best": "Rekord: {arg1}",
        "wroom_restart": "R / SPACJA – jeszcze raz      Q – wyjście",
        "wroom_paused": "PAUZA",
        "wroom_hud": "WYNIK {arg1:06d}   PRĘDKOŚĆ {arg2:3d} km/h   ŻYCIA {arg3}",
        "download_fail": "błąd pobierania",
        "gpg_fail": "błąd weryfikacji GPG",
        "sha256_mismatch": "niezgodność SHA256",
        "install_failed": "błąd instalacji",
        "installed": "Zainstalowano {} pakietów.",
        "rollback_restored": "Przywrócono poprzedni stan z migawki.",
        "rollback_files": "Wycofano {} plików.",
        "no_history": "Brak historii transakcji.",
        "pinned_list": "Przypięte pakiety ({}):",
        "no_pinned": "Brak przypiętych pakietów.",
        "pinned_to": "przypięty do",
        "unpinned": "odpięty.",
        "not_pinned": "nie był przypięty.",
        "repo_added": "Dodano repozytorium: {}",
        "repo_exists": "Repozytorium już istnieje: {}",
        "updated_done": "Odświeżanie zakończone. {} pakietów w cache.",
        "indexes_refreshed": "Indeksy odświeżone.",
        "updates_available": "⚠ jest {} pakietów do zaktualizowania – wpisz: pag update",
        "upgrading": "Aktualizacje: {} pakietów",
        "all_up_to_date": "Wszystkie pakiety są aktualne.",
        "removing": "Usuwanie",
        "orphans_found": "Osierocone zależności ({}): {}",
        "flatpak_missing": "Flatpak nie jest zainstalowany.",
        "flatpak_adding": "Dodaję zdalne repozytorium Flathub...",
        "flatpak_searching": "Szukam '{}' we Flathub...",
        "flatpak_found": "Znaleziono {} wyników:",
        "flatpak_not_found": "nie znaleziono we Flathub",
        "flatpak_install_prompt": "Zainstalować {}? [T/n] ",
        "flatpak_installing": "Instalowanie {}...",
        "flatpak_installed": "Flatpak {} zainstalowany.",
        "flatpak_removed": "Flatpak {} usunięty.",
        "flatpak_not_installed": "Flatpak {} nie jest zainstalowany.",
        "flatpak_info_id": "ID",
        "flatpak_info_version": "Wersja",
        "flatpak_info_branch": "Gałąź",
        "flatpak_info_origin": "Źródło",
        "flatpak_info_size": "Rozmiar",
        "flatpak_info_desc": "Opis",
        "flatpak_updated": "Flapaki zaktualizowane.",
        "flatpak_update_failed": "Aktualizacja flatpaków nie powiodła się (szczegóły wyżej).",
        "flatpak_usage": "Użycie: pag flatpak <search|install|remove|list|update|info> [args]",
        "flatpak_scope": "Instalacja",
        "flatpak_menu_hint": "Zainstalowano i zweryfikowano, ale sesja może jej nie pokazać w menu: brak eksportów Flatpaka w XDG_DATA_DIRS.",
        "flatpak_menu_fix": "Dodaj /var/lib/flatpak/exports/share do XDG_DATA_DIRS (a .../exports/bin do PATH) w sesji i zaloguj się ponownie – PaganDE robi to w session/pagande-session.",
        "key_imported": "Klucz zaimportowany pomyślnie.",
        "key_removed": "Klucz usunięty: {}",
        "no_keys": "Brak zaufanych kluczy GPG.",
        "gpg_missing": "BRAK GNUPG – zainstaluj gnupg i spróbuj ponownie",
        "ssl_broken": "Python bez działającego modułu ssl (HTTPS niemożliwe) – napraw pakiety python/openssl (np. sudo pag install -f python).",
        "key_add_failed": "Import klucza nie powiódł się (błąd gpg) – klucz NIE został dodany.",
        "verify_ok": "Wszystkie {} plików sprawne.",
        "verify_errors": "Znaleziono {} problemów:",
        "cache_cleared": "{} plików ({:.2f} MB) usuniętych z cache.",
        "deployments_list": "Deploymenty ({}):",
        "no_deployments": "Brak deploymentów.",
        "active_deployment": "AKTYWNY",
        "deploy_rollback_ok": "Przełączono na deployment: {}",
        "deploy_rollback_fail": "Brak poprzedniego deploymentu.",
        "deploy_cleanup_ok": "Usunięto {} starych deploymentów.",
        "deploy_cleanup_none": "Nie ma deploymentów do wyczyszczenia (minimum {}).",
        "snapshot_none": "Brak snapshotów systemu.",
        "snapshot_list": "Snapshoty systemu ({}):",
        "snapshot_created": "Utworzono snapshot: {}.",
        "snapshot_deleted": "Usunięto snapshot: {}.",
        "snapshot_not_found": "Nie znaleziono snapshotu: {}",
        "snapshot_unsupported": "Snapshoty niedostępne: {}",
        "snapshot_rollback_next": "Następny start ustawiono na snapshot: {}",
        "snapshot_rollback_hint": "Wybierz ten wpis w menu GRUB: {}",
        "staging_prepare": "Przygotowuję {} pakietów w stagingu (system bez zmian)...",
        "staging_failed": "Etap przygotowania nieudany – system NIE został zmieniony.",
        "staging_commit": "Wszystkie pakiety przygotowane – nakładam zmiany...",
        "grub_refreshed": "Menu GRUB odświeżone.",
        "grub_failed": "GRUB: {}",
        "grub_no_initrd": "GRUB: wpis startowy bez initramfs – sprawdź /boot/initramfs-*.img",
        "crlf_fixed": "{}: usunięto CRLF (psuło grub-mkconfig).",
        "initramfs_links_fixed": "Naprawiono dowiązania initramfs.",
        "no_user_sessions": "brak aktywnych sesji użytkownika – jednostki wczytają się przy logowaniu.",
        "dry_run_done": "Dry-run – nic nie zmieniono.",
        "dry_run_plan": "Dry-run – plan transakcji (bez zmian):",
        "why_explicit": "zainstalowany jawnie",
        "why_dependency": "zależność od",
        "why_not_installed": "niezainstalowany",
        "rdepends_title": "Odwrotne zależności {} ({}):",
        "rdepends_none": "nic od niego nie zależy.",
        "optional_deps": "Opcjonalne zależności (nie są instalowane automatycznie):",
        "autoremove_ok": "Usunięto {} osieroconych pakietów.",
        "autoremove_none": "Brak osieroconych pakietów.",
        "downloaded": "Pobrano {} do cache ({:.2f} MB).",
        "sec_downgrade": "Downgrade blocked: {pkg} {new} < {old}",
        "sec_suid": "SUID stripped from {path}",
        "sec_https": "HTTPS required for repos",
        "sec_badname": "Invalid package name: {name}",
        "sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
        "sec_conflict": "File conflict: {path} owned by {owner}",
        "sec_audit": "{pkg} installed by {user}",
        "sec_locked": "Another pag process is running",
        "sec_downgrade_pl": "Blokada downgrade: {pkg} {new} < {old}",
        "sec_suid_pl": "SUID usuniety z {path}",
        "sec_https_pl": "Repozytorium wymaga HTTPS",
        "sec_badname_pl": "Nieprawidlowa nazwa pakietu: {name}",
        "sec_toobig_pl": "Paczka za duza: {size_mb}MB > {max_mb}MB",
        "sec_conflict_pl": "Konflikt plikow: {path} nalezy do {owner}",
        "sec_audit_pl": "{pkg} zainstalowany przez {user}",
        "sec_locked_pl": "Inny proces pag juz dziala",

        "provides_mapped": "{} → {} (provides)",
        "stats_title": "Statystyki PAG",
        "stats_packages": "Zainstalowane pakiety",
        "stats_files": "Śledzone pliki",
        "stats_size": "Całkowity rozmiar",
        "stats_cache": "Rozmiar cache",
        "stats_history": "Transakcje",
        "stats_last_update": "Ostatnia aktualizacja",
        "conf_pacnew": "Zmieniony plik konfiguracyjny zachowany; nowa wersja: {path}",
        "conf_pacsave": "Zmieniony plik konfiguracyjny zachowany jako {path}",
        "provides_conflict": "Wielu dostawców dla '{name}' ({providers}) – używam '{chosen}'",

        # Baza wypalona w obrazie ISO (pag base / base adopt)
        "base_title": "Baza z obrazu ISO",
        "base_no_manifest": "Ten system nie ma manifestu bazy (/usr/share/pag/base.json) – nie ma czego adoptować.",
        "base_iso_version": "Wersja obrazu",
        "base_total": "Pakiety bazy (z obrazu)",
        "base_tracked": "Zarządzane przez pag",
        "base_adoptable": "Do adoptowania z repo",
        "base_unmatched": "Bez odpowiednika w repo",
        "base_adopt_hint": "Adoptuj (pliki z obrazu zostaną zastąpione pakietami z repo): sudo pag base adopt",
        "base_unmatched_hint": "Te zostaną w wersji z obrazu (brak takiego pakietu w repo):",
        "base_more": "więcej",
        "base_nothing_selected": "Żadna z podanych nazw nie jest na liście do adoptowania.",
        "base_all_managed": "Wszystkie pakiety bazy są już zarządzane przez pag.",
        "base_adopt_plan": "Adoptowanie {} pakietów bazy z repo (~{:.0f} MB):",
        "base_dry_run": "Próba na sucho – nic nie zainstalowano.",
        "base_unmanaged_hint": "{} pakietów z obrazu ISO nie jest jeszcze zarządzanych przez pag – 'sudo pag base adopt' zamieni je na pakiety z repo (dopiero wtedy 'pag upgrade' je aktualizuje).",
        "base_overwrite": "{} pochodzi z obrazu ISO – pliki zostaną zastąpione (kopia zapasowa dla 'pag rollback').",
        "base_reboot_hint": "Baza zaadoptowana z repo – zrestartuj system, zanim zaczniesz używać nowych bibliotek/narzędzi.",
        "base_register_ok": "Zarejestrowano {} pakietów bazy w bazie pakietów ({} już było).",
        "base_register_plan": "Dry-run – zarejestrowałbym {} pakietów bazy.",
        "base_register_nocache": "Brak cache indeksu repo – zostawiono nazwy z buildera (uruchom 'sudo pag sync' i ponownie 'pag base register', aby je zmapować).",
        "base_register_renamed": "{} nazw dopasowano do nazw pakietów w repo.",
        "stats_base": "Baza (obraz) zarządzana",
    },
}

# ── i18n: komunikaty CLI (msgid = tekst EN) ─────────────────────────────
_EXTRA_I18N = {
    '  ⚠ PAG_INSECURE=1 – skipping local package signature verification': '  ⚠ PAG_INSECURE=1 – pomijam weryfikację podpisu pakietu lokalnego',
    '  ❌ No signature for package: {arg1}': '  ❌ Brak podpisu dla pakietu: {arg1}',
    '     A .pag.asc/.pag.sig file from the same source is required.': '     Wymagany jest plik .pag.asc/.pag.sig z tego samego źródła.',
    '  ❌ Invalid package signature: {arg1}': '  ❌ Nieprawidłowy podpis pakietu: {arg1}',
    '  ❌ No pinned repo key for the local package.': '  ❌ Brak przypiętego klucza repo dla lokalnego pakietu.',
    '     Run first: sudo pag sync': '     Uruchom najpierw: sudo pag sync',
    '  ❌ [SECURITY ERROR] Package was signed with a different repo key.': '  ❌ [SECURITY ERROR] Pakiet podpisano innym kluczem repo.',
    '     Expected: {arg1}': '     Oczekiwany: {arg1}',
    '     Received:  {arg1}': '     Otrzymany:  {arg1}',
    '  🔐 Package signature OK ({arg1})': '  🔐 Podpis pakietu OK ({arg1})',
    '  ⚡ Copying the active deployment...': '  ⚡ Kopiowanie aktywnego deploymentu...',
    '  ✅ Deployment: {arg1} ({arg2})': '  ✅ Deployment: {arg1} ({arg2})',
    '  ✅ First deployment: {arg1}': '  ✅ Pierwszy deployment: {arg1}',
    '  ⚠ Cannot create {arg1}: {arg2}': '  ⚠ Nie mogę utworzyć {arg1}: {arg2}',
    '  ⚠ Failed to create snapshot: {arg1}': '  ⚠ Nie udało się utworzyć snapshotu: {arg1}',
    '  ⚠ btrfs snapshot failed: {arg1}': '  ⚠ btrfs snapshot nie udał się: {arg1}',
    '  📸 System snapshot: {arg1} (subvol={arg2})': '  📸 Snapshot systemu: {arg1} (subvol={arg2})',
    '  ❌ Invalid snapshot path – refusing to delete.': '  ❌ Nieprawidłowa ścieżka snapshotu – odmawiam usunięcia.',
    '  ⏪ Snapshot: {arg1}': '  ⏪ Snapshot: {arg1}',
    '  💡 Reboot the system – GRUB will boot the selected snapshot.': '  💡 Zrestartuj system – GRUB uruchomi wybrany snapshot.',
    '  💡 At boot, choose an entry in the GRUB menu (snapshots section).': '  💡 Przy starcie wybierz wpis w menu GRUB (sekcja snapshotów).',
    '❌ Another pag update is in progress – try again later.': '❌ Inna aktualizacja pag jest w toku – spróbuj ponownie później.',
    '  ⚠ Failed to extract {arg1}: {arg2}': '  ⚠ Nie rozpakowano {arg1}: {arg2}',
    '  ⚠ Corrupted index cache {arg1}: {arg2}': '  ⚠ Uszkodzony cache indeksu {arg1}: {arg2}',
    '  ❌ {arg1}: cannot refresh index – {arg2} is read-only': '  ❌ {arg1}: nie można odświeżyć indeksu – {arg2} jest tylko-do-odczytu',
    '  ⚠ HTTP {arg1} for {arg2}': '  ⚠ HTTP {arg1} dla {arg2}',
    '  ⚠ Failed to download index {arg1}: {arg2}': '  ⚠ Błąd pobierania indeksu {arg1}: {arg2}',
    '  ⚠ Index downloaded, but failed to save cache ({arg1}): {arg2}': '  ⚠ Indeks pobrany, ale nie udało się zapisać cache ({arg1}): {arg2}',
    '  ❌ {arg1}: no GPG keys – verification impossible!': '  ❌ {arg1}: brak kluczy GPG – weryfikacja niemożliwa!',
    '     Set PAG_INSECURE=1 to skip (not recommended)': '     Ustaw PAG_INSECURE=1 aby pominąć (niezalecane)',
    '  ❌ {arg1}: CANNOT DOWNLOAD SIGNATURE repo.json.asc/.sig!': '  ❌ {arg1}: NIE MOŻNA POBRAĆ PODPISU repo.json.asc/.sig!',
    '  🔑 Imported repo key from {arg1}/paganos.asc': '  🔑 Importowano klucz repo z {arg1}/paganos.asc',
    '  ⚠ {arg1}: invalid GPG signature (PAG_INSECURE – ignoring)': '  ⚠ {arg1}: nieprawidłowy podpis GPG (PAG_INSECURE – ignoruję)',
    '  ❌ {arg1}: GPG is not installed – cannot verify the signature!': '  ❌ {arg1}: GPG nie jest zainstalowane – nie można zweryfikować podpisu!',
    '     Install gnupg or set PAG_INSECURE=1 (not recommended)': '     Zainstaluj gnupg lub ustaw PAG_INSECURE=1 (niezalecane)',
    '  ❌ {arg1}: INVALID GPG SIGNATURE of the repository index!': '  ❌ {arg1}: NIEPRAWIDŁOWY PODPIS GPG indeksu repozytorium!',
    '  ⚠ {arg1}: cannot read signature fingerprint (PAG_INSECURE – ignoring)': '  ⚠ {arg1}: nie można odczytać fingerprintu (PAG_INSECURE – ignoruję)',
    '  ❌ [SECURITY ERROR] {arg1}: cannot read signature fingerprint!': '  ❌ [SECURITY ERROR] {arg1}: nie można odczytać fingerprintu podpisu!',
    '     Pinned key: {arg1} – rejecting the index.': '     Przypięty klucz: {arg1} – odrzucam indeks.',
    '  ⚠ {arg1}: SIGNING KEY CHANGED (PAG_INSECURE – ignoring)': '  ⚠ {arg1}: ZMIENIONY KLUCZ PODPISU (PAG_INSECURE – ignoruję)',
    '  ❌ [SECURITY ERROR] {arg1}: Repository signing key has changed!': '  ❌ [SECURITY ERROR] {arg1}: Klucz podpisujący repo uległ zmianie!',
    '     If this is an intentional key rotation: pag key-trust {arg1}': '     Jeśli to celowa rotacja klucza: pag key-trust {arg1}',
    '  🔐 Pinned repo fingerprint {arg1}: {arg2}': '  🔐 Przypięto fingerprint repo {arg1}: {arg2}',
    '     (TOFU – first trust. If the key changes, pag will refuse updates.)': '     (TOFU – pierwsze zaufanie. Gdy klucz się zmieni, pag odmówi aktualizacji.)',
    '     To avoid TOFU, add the fingerprint to /etc/pag/repos.conf.': '     Aby uniknąć TOFU, dopisz fingerprint w /etc/pag/repos.conf.',
    '❌ Download error: {arg1}': '❌ Błąd pobierania: {arg1}',
    '🔐 Pinning repo key {arg1}...': '🔐 Przypinam klucz repo {arg1}...',
    '  ❌ Cannot read signature fingerprint (missing/failed).': '  ❌ Nie można odczytać fingerprintu podpisu (brak/nieudany).',
    '     Make sure the repo key is in the keyring (pag key-add <url|file>).': '     Upewnij się, że klucz repo jest w keyringu (pag key-add <url|file>).',
    '  ✅ Pinned {arg1} for {arg2}': '  ✅ Przypięto {arg1} dla {arg2}',
    '     From now on, a key change will be reported as SECURITY ERROR.': '     Od teraz zmiana klucza zostanie zgłoszona jako SECURITY ERROR.',
    '  ℹ {arg1} has no pinned fingerprint.': '  ℹ {arg1} nie ma przypiętego fingerprintu.',
    '  ✅ Removed pin for {arg1}.': '  ✅ Usunięto przypięcie dla {arg1}.',
    '  ❌ {arg1}: preparation stage failed ({arg2})': '  ❌ {arg1}: etap przygotowania nieudany ({arg2})',
    '  ❌ {arg1}: commit error – {arg2}': '  ❌ {arg1}: błąd commit – {arg2}',
    '  ⚠ ldconfig not found — linker cache was not refreshed.': '  ⚠ Nie znaleziono ldconfig — cache linkera nie został odświeżony.',
    '  ⚠ Failed to refresh ld.so cache: {arg1}': "  ⚠ Nie udało się odświeżyć cache'a ld.so: {arg1}",
    '      ⚠ {arg1} shared files preserved': '      ⚠ {arg1} plików współdzielonych zachowanych',
    '      ⚠ {arg1} sensitive system files preserved': '      ⚠ {arg1} wrażliwych plików systemowych zachowanych',
    '  🧹 Removed {arg1} obsolete files ({arg2})': '  🧹 Usunięto {arg1} nieaktualnych plików ({arg2})',
    '  🛠  Interrupted transaction detected – restored {arg1} missing files.': '  🛠  Wykryto przerwana transakcje – przywrocono {arg1} brakujacych plikow.',
    '  ⚠ Hook skipped (PAG_NO_HOOKS=1): {arg1} for {arg2}': '  ⚠ Hook pominięty (PAG_NO_HOOKS=1): {arg1} dla {arg2}',
    '  ⚠ Hook {arg1} for {arg2} exited with code {arg3}': '  ⚠ Hook {arg1} dla {arg2} zakończony z kodem {arg3}',
    '  ⚠ Hook {arg1} for {arg2} timed out ({arg3}s)': '  ⚠ Hook {arg1} dla {arg2} przekroczył timeout ({arg3}s)',
    '     Increase PAG_HOOK_TIMEOUT (e.g. PAG_HOOK_TIMEOUT=1800) and retry.': '     Zwiększ PAG_HOOK_TIMEOUT (np. PAG_HOOK_TIMEOUT=1800) i spróbuj ponownie.',
    '  ⚠ Hook {arg1} for {arg2}: {arg3}': '  ⚠ Hook {arg1} dla {arg2}: {arg3}',
    'Recent transactions ({arg1}):': 'Ostatnie transakcje ({arg1}):',
    '❌ No snapshot to restore.': '❌ Brak snapshotu do przywrócenia.',
    '⏪ Rolling back: {arg1} ({arg2})': '⏪ Wycofywanie: {arg1} ({arg2})',
    '   Packages: {arg1}': '   Pakiety: {arg1}',
    '  ❌ Package not found: {arg1}': '  ❌ Nie znaleziono pakietu: {arg1}',
    '  ❌ {arg1}: missing metadata.json': '  ❌ {arg1}: brak metadata.json',
    '  ❌ {arg1}: failed to read package ({arg2})': '  ❌ {arg1}: nie udało się odczytać pakietu ({arg2})',
    '  ↩ Preparation stage failed – the system was NOT changed.': '  ↩ Etap przygotowania nieudany – system NIE został zmieniony.',
    '  ↓ {arg1}-{arg2} (local) ... ': '  ↓ {arg1}-{arg2} (lokalny) ... ',
    '  ❌ Not enough disk space: need ~{arg1} MB, free {arg2} MB ({arg3})': '  ❌ Za mało miejsca na dysku: potrzeba ~{arg1} MB, wolne {arg2} MB ({arg3})',
    '  ⚠ Low disk space: {arg1} MB free, packages ~{arg2} MB (extracted will take more)': '  ⚠ Mało miejsca na dysku: wolne {arg1} MB, pakiety ~{arg2} MB (rozpakowane zajmą więcej)',
    '  ❌ {arg1} is mounted read-only – cannot install.': '  ❌ {arg1} jest zamontowane tylko-do-odczytu – nie można instalować.',
    '❌ Cannot continue – {arg1} missing dependencies.': '❌ Nie można kontynuować – {arg1} brakujących zależności.',
    '   Install the missing packages or add repositories.': '   Zainstaluj brakujące pakiety lub dodaj repozytoria.',
    '   Install the library provider or update the repository.': '   Zainstaluj dostawcę biblioteki lub zaktualizuj repozytorium.',
    '\n  🏗️  Creating a new deployment...': '\n  🏗️  Tworzenie nowego deploymentu...',
    '\n  ⏬ Downloading {arg1} packages in parallel...': '\n  ⏬ Pobieranie {arg1} pakietów równolegle...',
    '\n  🐧 Finalizing kernel/driver update (DKMS → depmod → initramfs → GRUB)...': '\n  🐧 Finalizuję aktualizację jądra/sterowników (DKMS → depmod → initramfs → GRUB)...',
    '\n  🐧 Finalizing kernel/driver update in deployment (depmod + initramfs)...': '\n  🐧 Finalizuję aktualizację jądra/sterowników w deploymencie (depmod + initramfs)...',
    '  ↩ Aborted BEFORE installation – no package was changed.': '  ↩ Przerwano PRZED instalacją – żadna paczka nie została zmieniona.',
    '  ❌ Failed to create snapshot (--snapshot mode) – aborting.': '  ❌ Nie udało się utworzyć snapshotu (tryb --snapshot) – przerywam.',
    '\n  ↩ Rolling back transaction ({arg1} errors)...': '\n  ↩ Cofanie transakcji ({arg1} błędów)...',
    '\n  🔄 Switching to deployment {arg1}...': '\n  🔄 Przełączanie na deployment {arg1}...',
    '  ✅ Active deployment: {arg1}': '  ✅ Aktywny deployment: {arg1}',
    '  💡 Restart required to reload the system.': '  💡 Restart wymagany do przeładowania systemu.',
    '  ⚠ {arg1}: not installed': '  ⚠ {arg1}: nie zainstalowano',
    '✅ ({arg1} files)': '✅ ({arg1} plików)',
    '\n✅ Removed {arg1}.': '\n✅ Usunięto {arg1}.',
    "   'pag remove-orphans' to clean up.": "   Uruchom 'pag remove-orphans', aby posprzątać.",
    '  ⚡ Trigger: {arg1} ({arg2})': '  ⚡ Wyzwalacz: {arg1} ({arg2})',
    '    ⚠ trigger {arg1} timed out (120 s)': '    ⚠ trigger {arg1} przekroczył limit czasu (120 s)',
    '    ⚠ trigger {arg1}: {arg2}': '    ⚠ wyzwalacz {arg1}: {arg2}',
    '❌ No repositories configured.': '❌ Brak repozytoriów w konfiguracji.',
    '🔄 Checking for pag update from {arg1}...': '🔄 Sprawdzam aktualizację pag z {arg1}...',
    '  ❌ Cannot download pag: {arg1}': '  ❌ Nie można pobrać pag: {arg1}',
    '  ⚠ Invalid update signature (PAG_INSECURE – ignoring)': '  ⚠ Nieprawidłowy podpis aktualizacji (PAG_INSECURE – ignoruję)',
    '  ❌ Invalid update signature – not updating.': '  ❌ Nieprawidłowy podpis aktualizacji – nie aktualizuję.',
    '  ❌ Cannot confirm the update signature fingerprint.': '  ❌ Nie można potwierdzić fingerprintu podpisu aktualizacji.',
    '  ⚠ Update signed with a different key (PAG_INSECURE – ignoring)': '  ⚠ Podpis aktualizacji innym kluczem (PAG_INSECURE – ignoruję)',
    '  ❌ [SECURITY ERROR] Update signed with a different key than the repo!': '  ❌ [SECURITY ERROR] Podpis aktualizacji innym kluczem niż repo!',
    '     Expected: {arg1}, received: {arg2}': '     Oczekiwany: {arg1}, Otrzymany: {arg2}',
    '  ❌ SHA256 mismatch! Expected {arg1}, got {arg2}': '  ❌ SHA256 niezgodny! Oczekiwano {arg1}, jest {arg2}',
    '  ✅ SHA256 matches': '  ✅ SHA256 zgodny',
    '  ❌ Syntax error in new pag: {arg1}': '  ❌ Błąd składni w nowym pag: {arg1}',
    '  ✅ Downloaded pag {arg1} (current {arg2}), signature verified': '  ✅ Pobrano pag {arg1} (obecny {arg2}), podpis zweryfikowany',
    '  ✅ Installed new pag. Old version kept as {arg1}': '  ✅ Zainstalowano nowy pag. Stary zachowany jako {arg1}',
    '  ⚠ A different pag is first in PATH: {arg1} (updated {arg2})': '  ⚠ W PATH pierwszy jest inny pag: {arg1} (zaktualizowano {arg2})',
    '     Remove the old copy: sudo rm {arg1}': '     Usuń starą kopię: sudo rm {arg1}',
    '   Restart pag to use the new version.': '   Uruchom ponownie pag, aby użyć nowej wersji.',
    '🔄 Refreshing indexes...': '🔄 Odświeżanie indeksów...',
    '  {arg1} {arg2}: {arg3} packages {arg4}': '  {arg1} {arg2}: {arg3} pakietów {arg4}',
    '  ⚠ New pag version {arg1} available – run: pag self-update': '  ⚠ Nowa wersja pag {arg1} dostępna – uruchom: pag self-update',
    '  🐧 Rebuilding initramfs (newer kernel)...': '  🐧 Przebudowa initramfs (nowsze jądro)...',
    'No packages installed.': 'Brak zainstalowanych pakietów.',
    'Installed ({arg1}):': 'Zainstalowane ({arg1}):',
    'Available ({arg1}):': 'Dostępne ({arg1}):',
    '❌ No results for: {arg1}': '❌ Brak wyników dla: {arg1}',
    "Results for '{arg1}' ({arg2}):": "Wyniki dla '{arg1}' ({arg2}):",
    "\n  ❌ '{arg1}' — not found.": "\n  ❌ '{arg1}' — nie znaleziono.",
    '     PaganOS repo: pag search {arg1}': '     Repo PaganOS: pag search {arg1}',
    '     Flathub:      pag flatpak search {arg1}': '     Flathub:      pag flatpak search {arg1}',
    '     Add repo:     pag repo-add <url>': '     Dodaj repo:   pag repo-add <url>',
    '      ... and {arg1} more (pag search {arg2})': '      ... i {arg1} więcej (pag search {arg2})',
    '      ... and {arg1} more (pag flatpak search {arg2})': '      ... i {arg1} więcej (pag flatpak search {arg2})',
    '  ✓ {arg1} is already installed ({arg2})': '  ✓ {arg1} jest już zainstalowany ({arg2})',
    "❌ '{arg1}' not found.": "❌ Nie znaleziono '{arg1}'.",
    '   Version (repo):  {arg1}': '   Wersja (repo):  {arg1}',
    '   Description:     {arg1}': '   Opis:            {arg1}',
    '   Size:            {arg1:.1f} MB': '   Rozmiar:         {arg1:.1f} MB',
    '   SHA256:          {arg1}...': '   SHA256:          {arg1}...',
    '   GPG:             {arg1}': '   GPG:             {arg1}',
    '   Dependencies:    {arg1}': '   Zależności:      {arg1}',
    '   Installed:       {arg1} ({arg2})': '   Zainstalowany:   {arg1} ({arg2})',
    "❌ '{arg1}' not installed.": "❌ '{arg1}' nie jest zainstalowany.",
    'Files in {arg1} ({arg2}):': 'Pliki w {arg1} ({arg2}):',
    'Nothing to repair (no packages installed).': 'Nic do naprawy (brak zainstalowanych pakietow).',
    '✅ All files are in place – nothing to repair.': '✅ Wszystkie pliki na miejscu – nic do naprawy.',
    '🔧 Packages with missing files: {arg1} (total {arg2} files)': '🔧 Pakiety z brakujacymi plikami: {arg1} (lacznie {arg2} plikow)',
    '\n(--dry-run: nothing is changed)': '\n(--dry-run: nic nie zmieniam)',
    '\n🔧 repair: {arg1}': '\n🔧 naprawa: {arg1}',
    '⚠ Repaired {arg1}/{arg2}. Failed: {arg3}': '⚠ Naprawiono {arg1}/{arg2}. Nie udalo sie: {arg3}',
    '✅ Repaired {arg1} packages.': '✅ Naprawiono {arg1} pakietow.',
    'Nothing to verify.': 'Nie ma czego weryfikować.',
    '✅ No orphans.': 'Brak osieroconych pakietów.',
    'Orphans ({arg1}):': 'Osierocone ({arg1}):',
    '  ⚠ Search error: {arg1}': '  ⚠ Błąd wyszukiwania: {arg1}',
    '\n  Choose a number (1-{arg1}) or press Enter to cancel:': '\n  Wybierz numer (1-{arg1}) lub Enter aby anulować: ',
    "  📦 {arg1} – already installed (use 'pag flatpak info {arg2}' for details)": "  📦 {arg1} – już zainstalowany (szczegóły: 'pag flatpak info {arg2}')",
    "\n  Multiple matches for '{arg1}':": "\n  Wiele dopasowań dla '{arg1}':",
    '\n  Choose a number (1-{arg1}) or press Enter:': '\n  Wybierz numer (1-{arg1}) lub Enter: ',
    '  ... and {arg1} more. Refine your query.': '  ... i {arg1} więcej. Doprecyzuj zapytanie.',
    '\n  Choose a number to install (1-{arg1}) or press Enter to cancel:': '\n  Wybierz numer do zainstalowania (1-{arg1}) lub Enter aby anulować: ',
    '  (no installed flatpaks)': '  (brak zainstalowanych flatpaków)',
    'Installed flatpaks ({arg1}):': '  Zainstalowane flatpaki ({arg1}):',
    '  🔄 Updating flatpaks...': '  🔄 Aktualizacja flatpaków...',
    '\n  💡 To install: pag flatpak install {arg1}': '\n  💡 Aby zainstalować: pag flatpak install {arg1}',
    '  🔧 DKMS: rebuilding out-of-tree modules (nvidia/vbox)...': '  🔧 DKMS: przebudowa modułów out-of-tree (nvidia/vbox)...',
    '  🔧 Refreshing module dependencies (depmod)...': '  🔧 Odświeżanie zależności modułów (depmod)...',
    '  🔧 Rebuilding initramfs (pagan-initramfs)...': '  🔧 Przebudowa initramfs (pagan-initramfs)...',
    '  🔧 Rebuilding initramfs (dracut)...': '  🔧 Przebudowa initramfs (dracut)...',
    '  🔧 Rebuilding initramfs (mkinitcpio)...': '  🔧 Przebudowa initramfs (mkinitcpio)...',
    '  ⚠ No dracut/mkinitcpio – initramfs was not rebuilt': '  ⚠ Brak dracut/mkinitcpio – initramfs nie został przebudowany',
    '  🔧 Building initramfs for the deployment...': '  🔧 Budowanie initramfs dla deploymentu...',
    '  ⚠ pag-initramfs-init not found – skipping initramfs build': '  ⚠ Nie znaleziono pag-initramfs-init – pomijam budowę initramfs',
    "  ⚠ No vmlinuz-* found in the deployment's /boot": '  ⚠ Nie znaleziono vmlinuz-* w /boot deploymentu',
    '  🐧 Kernel: {arg1}': '  🐧 Jądro: {arg1}',
    '  ⚠ Skipping unavailable files: {arg1}': '  ⚠ Pomijam niedostępne pliki: {arg1}',
    '  ⚠ Skipping unavailable file: {arg1}': '  ⚠ Pomijam niedostępny plik: {arg1}',
    '  ✅ initramfs.img ({arg1:.1f} MB) → {arg2}': '  ✅ initramfs.img ({arg1:.1f} MB) → {arg2}',
    '  ❌ initramfs build error: {arg1}': '  ❌ Błąd budowy initramfs: {arg1}',
    '🏗️  Deployment: {arg1}': '🏗️  Deployment: {arg1}',
    '✅ Initramfs updated.': '✅ Initramfs zaktualizowany.',
    '❌ Initramfs update failed.': '❌ Błąd aktualizacji initramfs.',
    '  📋 Regenerating GRUB (grub-mkconfig)...': '  📋 Regeneracja GRUB (grub-mkconfig)...',
    '  ⚠ Could not detect the root partition – GRUB entries will have no root=.': '  ⚠ Nie udało się wykryć partycji root – wpisy GRUB nie dostaną root=.',
    '     Set PAG_ROOT_DEVICE=/dev/... (or PAG_GRUB_ROOT) and retry.': '     Ustaw PAG_ROOT_DEVICE=/dev/... (lub PAG_GRUB_ROOT) i powtórz.',
    '  📋 GRUB config updated – entries for each deployment': '  📋 GRUB config zaktualizowany – wpisy dla każdego deploymentu',
    '📋 Updating GRUB configuration...': '📋 Aktualizacja konfiguracji GRUB...',
    '✅ GRUB updated.': '✅ GRUB zaktualizowany.',
    '     +{arg1} more...': '     +{arg1} więcej...',
    '❌ Deployment {arg1} does not exist on disk': '❌ Deployment {arg1} nie istnieje na dysku',
    '⏪ Restoring deployment: {arg1}': '⏪ Przywracanie deploymentu: {arg1}',
    '\n❌ {arg1} – cannot install:': '\n❌ {arg1} – nie można zainstalować:',
    '   {arg1} → needs {arg2} (missing from repositories)': '   {arg1} → potrzebuje {arg2} (brak w repozytoriach)',
    '\n⚠ {arg1} – will be installed as dependencies:': '\n⚠ {arg1} – zostaną doinstalowane:',
    '   {arg1} → {arg2} ({arg3} – will be downloaded)': '   {arg1} → {arg2} ({arg3} – będzie pobrane)',
    '   {arg1} → requires {arg2} – no package provides this version': '   {arg1} → wymaga {arg2} – żaden pakiet nie dostarcza tej wersji',
    '  ↻ Retrying download of {arg1} ({arg2}/{arg3})...': '  ↻ Ponawiam pobieranie {arg1} ({arg2}/{arg3})...',
    '  ⚠ Download error {arg1}: {arg2}': '  ⚠ Błąd pobierania {arg1}: {arg2}',
    '❌ Format: spdx | cyclonedx': '❌ Format: spdx | cyclonedx',
    '  ✓ {arg1} ({arg2} keys)': '  ✓ {arg1} ({arg2} kluczy)',
    'Usage: pag search <query>': 'Użycie: pag search <query>',
    'Usage: pag info <pkg>': 'Użycie: pag info <pkg>',
    'Usage: pag files <pkg>': 'Użycie: pag files <pkg>',
    'Usage: pag why <pkg>': 'Użycie: pag why <pkg>',
    'Usage: pag rdepends <pkg>': 'Użycie: pag rdepends <pkg>',
    'Usage: pag flatpak-search <query>': 'Użycie: pag flatpak-search <query>',
    'Usage: pag flatpak-info <id>': 'Użycie: pag flatpak-info <id>',
    "❌ Unknown command: '{arg1}'. Did you mean '{arg2}'?": "❌ Nieznana komenda: '{arg1}'. Czy chodziło o '{arg2}'?",
    "   Run 'pag' without arguments to see the command list.": "   Uruchom 'pag' bez argumentów, aby zobaczyć listę komend.",
    'Usage: pag unpin <pkg>': 'Użycie: pag unpin <pkg>',
    'Usage: pag repo-add <url> [name]': 'Użycie: pag repo-add <url> [name]',
    'Usage: pag key-add <url|file>': 'Użycie: pag key-add <url|file>',
    'Usage: pag key-remove <id>': 'Użycie: pag key-remove <id>',
    'Usage: pag key-trust <repo_url>': 'Użycie: pag key-trust <repo_url>',
    'Usage: pag key-untrust <repo_url>': 'Użycie: pag key-untrust <repo_url>',
    'Usage: pag flatpak-install <app>': 'Użycie: pag flatpak-install <app>',
    'Usage: pag flatpak-remove <app>': 'Użycie: pag flatpak-remove <app>',
    'Usage: pag snapshot-delete <id>': 'Użycie: pag snapshot-delete <id>',
    '\n  ⚠ Interrupted (Ctrl-C).': '\n  ⚠ Przerwano (Ctrl-C).',
}
for _msgid, _pl in _EXTRA_I18N.items():
    T["en"].setdefault(_msgid, _msgid)
    T["pl"].setdefault(_msgid, _pl)

_AUX_I18N = {
    'installed_marker': ('installed', 'zainstalowany'),
    'none_value': ('none', 'brak'),
    'none_parenthesized': ('(none)', '(brak)'),
    'stats_top': ('Top 5:', 'Największe 5:'),
    'never': ('never', 'nigdy'),
    'action_install': ('install', 'instalacja'),
    'action_upgrade': ('upgrade', 'aktualizacja'),
    'action_remove': ('remove', 'usunięcie'),
    'action_rollback': ('rollback', 'wycofanie'),
    'action_manual': ('manual', 'ręczny'),
    'action_repair': ('repair', 'naprawa'),
    'flatpak_searching_any': ('Searching Flathub...', 'Szukam we Flathub...'),
    'upgrade_marker': ('[upgrade]', '[aktualizacja]'),
    'hardlink_method': ('hardlinks', 'hardlinki'),
    'copy_method': ('full copy', 'pełna kopia'),
    'reflink_method': ('CoW (reflink)', 'CoW (reflink)'),
    'verify_missing_file': ('  ❌ {}: missing {}', '  ❌ {}: brakuje {}'),
    'verify_sha_mismatch': ('  ❌ {}: SHA256 mismatch {}', '  ❌ {}: niezgodność SHA256 {}'),
    'gpg_binary_not_found': ('GPG binary not found ({})', 'Nie znaleziono binarki GPG ({})'),
    'gpg_timeout': ('GPG operation timed out', 'Operacja GPG przekroczyła limit czasu'),
    'audio_services_reloaded': ('  ⚡ audio services reloaded for sessions: {}', '  ⚡ przeładowano usługi audio dla sesji: {}'),
    'grub_fallback_label': ('Pagan Linux – fallback (plain root)', 'Pagan Linux – fallback (zwykły root)'),
    'done': ('done', 'gotowe'),
    'deploy_copy_failed': ('Failed to copy the deployment by any method', 'Nie udało się skopiować deploymentu żadną metodą'),
    'pkg_missing_data_tar': ('missing data.tar.xz in package', 'brak data.tar.xz w pakiecie'),
    'pkg_sha_mismatch': ('SHA256 mismatch: {}', 'niezgodność SHA256: {}'),
    'repo_index_invalid': ("missing 'packages' list", "brak listy 'packages'"),
}
for _k, (_en, _pl) in _AUX_I18N.items():
    T["en"].setdefault(_k, _en)
    T["pl"].setdefault(_k, _pl)

# ── Tłumaczenia z PLIKÓW (nadpisują/rozszerzają wbudowane PL/EN) ─────────────
# Kolejność: PAG_LANG_DIR (env) → /etc/pag/lang → /usr/share/pag/lang →
# ./pag-lang obok binarki (dev). Brak plików NIE jest błędem – zostaje
# wbudowany słownik T (fallback), więc pag zawsze działa.
# Przykład pliku (pag-lang/pl.json): {"app_title": "...", "usage": "..."}.
def _load_lang_files() -> None:
    # PAG_LANG_NO_FILES=1 → pomiń pliki (używane przy eksporcie --lang-extract,
    # żeby wyeksportować CZYSTE wbudowane słowniki, bez starych nadpisań).
    if os.environ.get("PAG_LANG_NO_FILES") == "1":
        return
    dirs = []
    _env = os.environ.get("PAG_LANG_DIR")
    if _env:
        dirs.append(_env)
    # __file__ bywa niedostępne, gdy moduł jest exec/frozen (np. harness
    # instalacyjny) – liczymy wtedy od ścieżki programu, zamiast wywalać
    # NameError przy samym imporcie.
    _self = globals().get("__file__") or sys.argv[0] or "pag"
    dirs += ["/etc/pag/lang", "/usr/share/pag/lang",
             os.path.join(os.path.dirname(os.path.abspath(_self)), "pag-lang")]
    for _d in dirs:
        for _code in list(T.keys()) + ["pl", "en", "de"]:
            _p = os.path.join(_d, f"{_code}.json")
            try:
                with open(_p, "r", encoding="utf-8") as _fh:
                    _data = json.load(_fh)
                if isinstance(_data, dict):
                    # Merge (nie replace): klucze nieobecne w pliku zachowują
                    # wbudowane tłumaczenie. Puste wartości pomijamy, żeby
                    # niekompletny/uszkodzony plik nie wyczyścił komunikatu.
                    _clean = {str(k): str(v) for k, v in _data.items()
                              if str(v).strip()}
                    T.setdefault(_code, {}).update(_clean)
            except (OSError, ValueError):
                continue


_load_lang_files()

def _(key: str, *args, **kwargs) -> str:
    """Tłumaczy klucz i formatuje argumenty.

    Dla LANG=pl preferuje wariant „<key>_pl” (np. komunikaty bezpieczeństwa
    mają krótkie wersje PL obok bazy EN), potem zwykły klucz, potem EN/klicz.
    """
    if LANG == "pl":
        _pl = T.get("pl", {})
        msg = _pl.get(key + "_pl") or _pl.get(key) or T["en"].get(key, key)
    else:
        msg = T.get(LANG, T["en"]).get(key, T["en"].get(key, key))
    if args or kwargs:
        return msg.format(*args, **kwargs)
    return msg


def _ask_confirm() -> bool:
    """Pytanie potwierdzające (T/n). PAG_YES=1 → zawsze tak.

    EOF/brak terminala (stdin zamknięty, np. ssh bez TTY, cron, subprocess
    panelu webowego) → NIE – anuluj, nie wykonuj operacji bez potwierdzenia
    (inaczej input() rzuca EOFError i pag pada tracebackiem).
    Enter → tak (domyślne Y/n).
    """
    if os.environ.get("PAG_YES", "") == "1":
        print(_("continue_q") + " t (--yes)")
        return True
    try:
        ans = input(_("continue_q")).strip().lower()
    except (EOFError, KeyboardInterrupt):
        print(f"\n  ⚠ {_('no_tty')}")
        return False
    return not ans or ans in ("t", "y")


# =============================================================================
# ŚCIEŻKI
# =============================================================================
PAG_ROOT      = os.environ.get("PAG_ROOT", "/")
PAG_DB        = "/var/lib/pag"
PAG_CACHE     = "/var/cache/pag"
PAG_CONF      = "/etc/pag"
REPO_CACHE    = "/var/cache/pag/repos"
REPOS_CONF    = "/etc/pag/repos.conf"
REPOS_DIR     = PAG_CONF + "/repos"   # drop-in: /etc/pag/repos/<nazwa>.conf
INSTALLED_DB  = "/var/lib/pag/installed.json"
FILES_DB_SQL  = "/var/lib/pag/files.db"       # SQLite!
WORLD_FILE    = "/var/lib/pag/world"
PINNED_FILE   = "/var/lib/pag/pinned.json"
HISTORY_FILE  = "/var/lib/pag/history.json"
LOCK_FILE     = "/var/lib/pag/pag.lock"
STAGING_DIR   = "/.pag_staging"          # na tej samej partycji co / (unikamy EXDEV)
PKG_EXT       = ".pag"
REPO_CACHE_TTL = 3600
MAX_PKG_SIZE  = 2 * 1024 * 1024 * 1024  # 2 GB – maksymalny rozmiar paczki
BASE_MANIFEST = "/usr/share/pag/base.json"   # baza z obrazu ISO (pag base/adopt)

# ── UPRZYWILEJOWANE PLIKI ────────────────────────────────────────────────────
# Domyślnie pag zdejmuje bit SUID i wymusza właściciela root:root. Niektóre
# programy MUSZĄ jednak zachować setuid/setgid albo grupę inną niż root
# (/usr/bin/sudo, /usr/bin/passwd, /usr/bin/unix_chkpwd,
# /usr/lib/dbus-daemon-launch-helper). Bez tego tracą możliwość działania
# po aktualizacji przez pag (np. użytkownik nie zmieni hasła).
#
# Bezpieczeństwo: zawartość pakietu jest uwierzytelniona (podpis GPG repo +
# przypięty fingerprint + SHA256 całego pakietu), więc metadane w nim są
# zaufane tak samo jak same pliki. Zachowujemy uprawnienia WYŁĄCZNIE dla
# ścieżek z tej listy (albo z pola `privileged:` receptury, które pagbuild
# zapisuje w metadata.json).
PRIVILEGED_PATHS = frozenset({
    "/usr/bin/cdda2wav", "/usr/bin/cdrecord",
    "/usr/bin/chage", "/usr/bin/expiry",
    "/usr/bin/fcrondyn", "/usr/bin/fcronsighup", "/usr/bin/fcrontab",
    "/usr/bin/firejail", "/usr/bin/fping",
    "/usr/bin/fusermount", "/usr/bin/fusermount3",
    "/usr/bin/gpasswd", "/usr/bin/ksu", "/usr/bin/lockfile",
    "/usr/bin/mount", "/usr/bin/mount.nfs",
    "/usr/bin/newgidmap", "/usr/bin/newuidmap",
    "/usr/bin/passwd", "/usr/bin/ping", "/usr/bin/ping6",
    "/usr/bin/procmail", "/usr/bin/readcd", "/usr/bin/rscsi",
    "/usr/bin/screen", "/usr/bin/screen-5.0.2",
    "/usr/bin/sg", "/usr/bin/su", "/usr/bin/sudo", "/usr/bin/traceroute",
    "/usr/bin/umount", "/usr/bin/unix_chkpwd", "/usr/bin/wall",
    "/usr/lib/dbus-daemon-launch-helper",
    "/usr/lib/httpd/suexec",
    "/usr/lib/utempter/utempter",
    "/usr/lib/xscreensaver/xscreensaver-auth",
    "/usr/libexec/libgtop_server2",
    "/usr/libexec/qemu-bridge-helper",
    "/usr/libexec/ssh-keysign",
    "/usr/libexec/xf86-video-intel-backlight-helper",
    "/opt/google/chrome/chrome-sandbox",
    "/opt/gitkraken/chrome-sandbox",
    "/opt/VirtualBox/VBoxHeadless", "/opt/VirtualBox/VBoxNetAdpCtl",
    "/opt/VirtualBox/VBoxNetDHCP", "/opt/VirtualBox/VBoxVolInfo",
    "/opt/VirtualBox/VirtualBoxVM",
})
ALLOWED_PKG_RE = re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9._+@-]*$')

# Bezpieczeństwo / audyt
AUDIT_LOG      = "/var/log/pag/audit.log"      # dziennik operacji krytycznych (hooki, self-update)
TRUST_DB       = "/etc/pag/trusted.json"        # mapa repo_url → fingerprint klucza podpisującego
HOOK_API_VERSION = "1"                          # wersjonowane API hooków (env PKG_HOOK_API)

# =============================================================================
# IMMUTABLE OS – DEPLOYMENTY
# =============================================================================
# Model: zamiast mutować /, każda operacja tworzy NOWY deployment.
# /var, /etc, /home są współdzielone między deploymentami.
#
# STRUKTURA:
#   /.deployments/
#     active → 20260723T120000       (symlink do aktywnego)
#     20260723T120000/
#       usr/ bin/ lib/ lib64/ ...    (pełny system)
#       var → /var                   (symlink do współdzielonego)
#       etc → /etc
#       home → /home
#     ...
#
# Jak to działa:
#   1. pag install → kopiuje active → nowy deployment + nakłada zmiany → switch symlinka
#   2. pag remove  → kopiuje active → nowy deployment - usuwa pliki → switch symlinka
#   3. pag deploy-rollback → przełącza active symlink na poprzedni deployment
#   4. Przy starcie systemu: initrd montuje /.deployments/active jako /
# =============================================================================

DEPLOYMENTS_DIR  = "/.deployments"
ACTIVE_LINK      = "/.deployments/active"
DEPLOYMENTS_DB   = "/var/lib/pag/deployments.json"

# Snapshoty systemu (CoW). Na btrfs każdy snapshot jest osobnym subwolumenem,
# więc zajmuje tylko zmienione bloki, a GRUB potrafi uruchomić system z wybranej
# migawki (rootflags=subvol=...). Na ext4/xfs nie ma snapshotów CoW – zostaje
# atomowy staging + backup nadpisywanych plików.
SNAPSHOTS_DIR    = "/.pag_snapshots"
SNAPSHOTS_DB     = "/var/lib/pag/snapshots.json"
GRUB_SNAPSHOT_SCRIPT = "/etc/grub.d/40_pagan_snapshots"

# Ścieżki współdzielone – NIE wchodzą do deploymentu (są symlinkami do /...)
SHARED_PATHS = {
    "/var", "/etc", "/home", "/root", "/tmp", "/run",
    "/dev", "/proc", "/sys", "/mnt", "/media", "/srv",
    # /boot współdzielone: jądro + initramfs są wspólne dla wszystkich
    # deploymentów (inaczej każdy trzyma własną ~50-100 MB kopię). GRUB
    # wskazuje na /.deployments/<id>/boot → symlink do /boot.
    "/boot",
    "/.deployments", "/.pag_staging",
}

def _is_shared_path(rel: str) -> bool:
    """Sprawdza czy ścieżka należy do katalogów współdzielonych (poza deploymentem)."""
    for sp in SHARED_PATHS:
        if rel == sp or rel.startswith(sp + "/"):
            return True
    return False

def _is_config_path(rel: str) -> bool:
    """Czy ścieżka to plik konfiguracyjny (/etc/...)?

    Dla takich plików stosujemy .pacnew/.pacsave (zachowanie zmian użytkownika)
    zamiast bezwarunkowego nadpisania/usunięcia."""
    p = rel.lstrip("/")
    return p == "etc" or p.startswith("etc/")

# Wrażliwa konfiguracja auth/systemowa – NIGDY nie nadpisujemy jej po cichu.
# Nadpisanie /etc/pam.d/system-* przez pakiet (np. shadow) potrafi zablokować
# logowanie/sudo („account validation failure”); dla tych ścieżek zawsze robimy
# .pacnew, gdy treść na dysku różni się od tej z pakietu.
_SENSITIVE_CONFIG_RE = re.compile(
    r'^(pam\.d/|security/|sudoers$|sudoers\.d/|shadow$|gshadow$|passwd$|group$|'
    r'login\.defs$|nsswitch\.conf$|default/useradd$)')

def _is_sensitive_config(rel: str) -> bool:
    """Czy rel to wrażliwy plik /etc (PAM, sudoers, shadow, login.defs…)?"""
    p = rel.lstrip("/")
    if not p.startswith("etc/"):
        return False
    return bool(_SENSITIVE_CONFIG_RE.match(p[4:]))

def _get_deployment_root() -> str:
    """Zwraca ścieżkę do aktywnego deploymentu, lub PAG_ROOT jeśli tryb niemutowalny wyłączony."""
    if os.environ.get("PAG_IMMUTABLE", "") in ("0", "no", "false", ""):
        return PAG_ROOT
    if os.path.islink(ACTIVE_LINK):
        return os.readlink(ACTIVE_LINK)
    if os.path.isdir(ACTIVE_LINK):
        return ACTIVE_LINK
    # Brak deploymentów – użyj /
    return PAG_ROOT

def _load_deployments() -> List[dict]:
    """Wczytuje historię deploymentów."""
    if not os.path.exists(DEPLOYMENTS_DB):
        return []
    try:
        return json.load(open(DEPLOYMENTS_DB))
    except Exception:
        return []

def _save_deployments(deployments: List[dict]):
    os.makedirs(os.path.dirname(DEPLOYMENTS_DB), exist_ok=True)
    json.dump(deployments, open(DEPLOYMENTS_DB, "w"), indent=2)

def _create_deployment(pkg_names: List[str], action: str) -> Tuple[str, str]:
    """
    Tworzy nowy deployment przez skopiowanie aktywnego (CoW) i zwraca jego ścieżkę.
    Zwraca (deployment_dir, deployment_id).
    """
    deploy_id = datetime.now().strftime("%Y%m%dT%H%M%S")
    deploy_dir = os.path.join(DEPLOYMENTS_DIR, deploy_id)
    os.makedirs(DEPLOYMENTS_DIR, exist_ok=True)

    active = _get_deployment_root()

    if os.path.isdir(active) and active != PAG_ROOT:
        # Trójstopniowa strategia kopiowania deploymentu:
        # 1. reflink (CoW – btrfs, xfs)         → 0 MB kopiowane
        # 2. hardlink (linki twarde)             → 0 MB kopiowane, tylko inody
        # 3. zwykłe cp (ostateczność)            → pełna kopia
        print(_('  ⚡ Copying the active deployment...'))
        copied = False
        for method, cmd, label in [
            ("reflink", ["cp", "--reflink=auto", "-a", active + "/.", deploy_dir + "/"], _("reflink_method")),
            ("hardlink", ["cp", "-al", active + "/.", deploy_dir + "/"], _("hardlink_method")),
            ("copy",    ["cp", "-a",  active + "/.", deploy_dir + "/"], _("copy_method")),
        ]:
            try:
                subprocess.run(cmd, check=True, timeout=600, capture_output=True)
                print(_('  ✅ Deployment: {arg1} ({arg2})', arg1=(deploy_id), arg2=(label)))
                copied = True
                break
            except subprocess.CalledProcessError:
                if method == "copy":
                    raise  # ostatnia deska – niech leci wyjątek
                continue
        if not copied:
            raise RuntimeError(_("deploy_copy_failed"))
    else:
        # Pierwszy deployment – tylko katalogi szkieletowe
        # /boot celowo POMINIĘTE – jest współdzielone (SHARED_PATHS); poniższa
        # pętla utworzy w deploymencie symlink boot → /boot.
        for d in ["/usr", "/lib", "/lib64", "/bin", "/sbin", "/opt"]:
            if os.path.isdir(d):
                dest = os.path.join(deploy_dir, d.lstrip("/"))
                os.makedirs(dest, exist_ok=True)
        print(_('  ✅ First deployment: {arg1}', arg1=(deploy_id)))

    # Utwórz symlinki do współdzielonych katalogów
    for sp in SHARED_PATHS:
        link_dst = os.path.join(deploy_dir, sp.lstrip("/"))
        if not os.path.lexists(link_dst) and os.path.isdir(sp):
            os.symlink(sp, link_dst)

    # Zapisz w bazie deploymentów
    deployments = _load_deployments()
    deployments.append({
        "id": deploy_id,
        "action": action,
        "packages": pkg_names,
        "timestamp": datetime.now().isoformat(),
        "active": True,
    })
    # Oznacz poprzednie jako nieaktywne
    for d in deployments[:-1]:
        d["active"] = False
    _save_deployments(deployments)

    return deploy_dir, deploy_id

def _switch_deployment(deploy_dir: str) -> bool:
    """Atomowo przełącza aktywny deployment przez podmianę symlinka."""
    tmp_link = ACTIVE_LINK + ".new"
    if os.path.lexists(tmp_link):
        os.remove(tmp_link)
    os.symlink(deploy_dir, tmp_link)
    os.rename(tmp_link, ACTIVE_LINK)  # atomowe na tym samym FS
    return True

# =============================================================================
# SNAPSHOTY SYSTEMU (CoW – btrfs)
# =============================================================================
# Snapshot powstaje PRZED transakcją. Na btrfs to subwolumen (kilka KB
# metadanych, reszta to współdzielone bloki), więc nie kopiujemy całego
# systemu. Wpis GRUB pozwala uruchomić system z wybranej migawki.
# Na ext4/xfs nie ma CoW – instalacja nadal jest atomowa dzięki stagingowi,
# a rollback opiera się na backupie nadpisywanych plików.

def _btrfs_bin() -> str:
    """Ścieżka do btrfs (PATH bywa okrojony w chroocie/instalatorze)."""
    found = shutil.which("btrfs")
    if found:
        return found
    for cand in ("/usr/bin/btrfs", "/usr/sbin/btrfs", "/sbin/btrfs", "/bin/btrfs"):
        if os.path.exists(cand):
            return cand
    return ""


def _root_fstype() -> str:
    try:
        r = subprocess.run(["findmnt", "-n", "-o", "FSTYPE", "/"],
                           capture_output=True, text=True, timeout=5)
        fs = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
        if fs:
            return fs
    except Exception:
        pass
    try:
        r = subprocess.run(["stat", "-f", "-c", "%T", "/"],
                           capture_output=True, text=True, timeout=5)
        return r.stdout.strip()
    except Exception:
        return ""


def _btrfs_root_path() -> str:
    """Ścieżka aktywnego subwolumenu root względem top-level btrfs."""
    btrfs = _btrfs_bin()
    if btrfs:
        try:
            r = subprocess.run([btrfs, "subvolume", "show", "/"],
                               capture_output=True, text=True, timeout=5)
            if r.returncode == 0:
                for line in r.stdout.splitlines():
                    line = line.strip()
                    if line.lower().startswith("path:"):
                        p = line.split(":", 1)[1].strip()
                        if p in ("", "/"):
                            return "/"
                        return p.strip("/")
        except Exception:
            pass
    try:
        r = subprocess.run(["findmnt", "-n", "-o", "FSROOT", "/"],
                           capture_output=True, text=True, timeout=5)
        p = r.stdout.strip()
        if p and p != "/":
            return p.strip("/")
    except Exception:
        pass
    return "/"


def _snapshot_support() -> Tuple[bool, str]:
    fs = _root_fstype()
    if fs != "btrfs":
        return False, (f"root jest na {fs or 'nieznanym systemie plików'} – "
                       f"snapshoty CoW wymagają btrfs")
    if not _btrfs_bin():
        return False, "brak narzędzia btrfs (zainstaluj pakiet btrfs-progs)"
    return True, ""


def _load_snapshots() -> List[dict]:
    if not os.path.exists(SNAPSHOTS_DB):
        return []
    try:
        data = load_json(SNAPSHOTS_DB)
        return data if isinstance(data, list) else []
    except Exception:
        return []


def _save_snapshots(items: List[dict]):
    os.makedirs(os.path.dirname(SNAPSHOTS_DB), exist_ok=True)
    save_json(SNAPSHOTS_DB, items)


def _snapshot_label(snap: dict) -> str:
    """Czytelna etykieta GRUB (bez znaków, które psują menu)."""
    pkgs = list(snap.get("packages") or [])
    p = ", ".join(pkgs[:3])
    if len(pkgs) > 3:
        p += f" +{len(pkgs) - 3}"
    base = f"Pagan Linux snapshot {snap.get('id', '?')}"
    if snap.get("label"):
        base += f" - {snap['label']}"
    if p:
        base += f" - {p}"
    # GRUB: usuń apostrofy i znaki kontrolne.
    return re.sub(r"[\x00-\x1f']", "", base)[:120]


def _root_boot_arg() -> str:
    """`root=UUID=...` dla wpisu GRUB (stabilne po zmianie nazw urządzeń)."""
    dev = _detect_root_device()
    if not dev:
        return ""
    if dev.startswith(("UUID=", "PARTUUID=", "LABEL=", "PARTLABEL=")):
        return f" root={dev}"
    uuid = ""
    try:
        r = subprocess.run(["blkid", "-s", "UUID", "-o", "value", dev],
                           capture_output=True, text=True, timeout=5)
        uuid = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
    except Exception:
        uuid = ""
    return f" root=UUID={uuid}" if uuid else f" root={dev}"


def _initrd_for_kernel(boot_dir: str, kernel: str) -> str:
    """Nazwa initramfs pasująca do jądra (initramfs.img / initramfs-<ver>.img…)."""
    if not kernel or not os.path.isdir(boot_dir):
        return ""
    ver = kernel[len("vmlinuz-"):] if kernel.startswith("vmlinuz-") else ""
    candidates = []
    if ver:
        candidates += [f"initramfs-{ver}.img", f"initrd.img-{ver}"]
    candidates += ["initramfs.img", "initrd.img"]
    for c in candidates:
        if os.path.isfile(os.path.join(boot_dir, c)):
            return c
    for f in sorted(os.listdir(boot_dir)):
        if f.startswith(("initramfs", "initrd")):
            return f
    return ""


def _pick_kernel_initrd(boot_dir: str) -> Tuple[str, str]:
    kernels = sorted(
        [f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
        reverse=True,
    ) if os.path.isdir(boot_dir) else []
    if not kernels:
        return "", ""
    k = kernels[0]
    return k, _initrd_for_kernel(boot_dir, k)


def _grub_snapshot_entries() -> List[str]:
    """Wpisy menu GRUB dla snapshotów (dla `_update_grub_config` i grub.d)."""
    snaps = _load_snapshots()
    if not snaps:
        return []

    root_arg = _root_boot_arg()
    try:
        separate_boot = os.path.isdir("/boot") and os.path.ismount("/boot")
    except OSError:
        separate_boot = False
    bp = _boot_prefix()

    lines: List[str] = []
    for snap in reversed(snaps):
        path = snap.get("path") or ""
        if not path or not os.path.isdir(path):
            continue

        if separate_boot:
            # Osobne /boot jest współdzielone: użyj jądra ZAPISANEGO przy
            # tworzeniu snapshotu (o ile nadal leży w /boot), a nie zawsze
            # najnowszego – nowe jądro mogło być właśnie przyczyną problemu.
            kname = snap.get("kernel") or ""
            if not kname or not os.path.isfile(os.path.join("/boot", kname)):
                kname, _ = _pick_kernel_initrd("/boot")
            iname = _initrd_for_kernel("/boot", kname) if kname else ""
            kernel = f"{bp}/{kname}" if kname else ""
            initrd = f"{bp}/{iname}" if iname else ""
        else:
            snap_boot = os.path.join(path, "boot")
            kname, iname = _pick_kernel_initrd(snap_boot)
            # Kopia zapasowa: jądro z bieżącego /boot (np. gdy /boot nie
            # było częścią snapshotu lub jest to bardzo stara migawka).
            if not kname:
                kname, iname = _pick_kernel_initrd("/boot")
                kernel = f"{bp}/{kname}" if kname else ""
                initrd = f"{bp}/{iname}" if iname else ""
            else:
                kernel = f"{path}/boot/{kname}"
                initrd = f"{path}/boot/{iname}" if iname else ""

        if not kernel:
            continue

        subvol = snap.get("subvol") or ""
        flags = f" rootflags=subvol={subvol} rootfstype=btrfs" if subvol else ""
        label = _snapshot_label(snap)

        lines.append(f"menuentry '{label}' --class pagan --class gnu-linux --class os {{")
        lines.append(f"    linux {kernel}{root_arg}{flags} rw quiet")
        if initrd:
            lines.append(f"    initrd {initrd}")
        lines.append("}")
        lines.append("")
    return lines


def _ensure_snapshot_grub_script() -> bool:
    """Instaluje /etc/grub.d/40_pagan_snapshots (integracja z grub-mkconfig)."""
    if not os.path.isdir("/etc/grub.d"):
        return False
    # Preferuj BIEŻĄCĄ binarkę (np. testy z repo), a nie starszy /usr/bin/pag:
    # stary pag nie zna `snapshot-grub` i uruchomiłby smart-search.
    _self = os.path.abspath(sys.argv[0]) if sys.argv[0] else ""
    exe = _self if _self and os.path.isfile(_self) else (shutil.which("pag") or "/usr/bin/pag")
    if not exe or not os.path.exists(exe):
        exe = "/usr/bin/pag"
    quoted = exe.replace("'", "'\\''")
    script = (
        "#!/bin/sh\n"
        "# Pagan Linux – wpisy GRUB dla snapshotów systemu (wygenerowane przez pag)\n"
        "# Usuń ten plik, aby ukryć snapshoty w menu GRUB.\n"
        f"PAG_BIN='{quoted}'\n"
        'if [ ! -x "$PAG_BIN" ]; then\n'
        '    PAG_BIN="$(command -v pag 2>/dev/null || true)"\n'
        "fi\n"
        '[ -x "$PAG_BIN" ] || exit 0\n'
        '# Tylko pag >= 4.1 zna komendę snapshot-grub (starszy zrobiłby\n'
        '# smart-search i mógłby zawiesić grub-mkconfig na sieci).\n'
        'case "$("$PAG_BIN" --version 2>/dev/null)" in\n'
        '    "pag 4."[1-9]*|"pag "[5-9]*|"pag "[1-9][0-9]*) ;;\n'
        '    *) exit 0 ;;\n'
        'esac\n'
        'exec "$PAG_BIN" snapshot-grub\n'
    )
    try:
        with open(GRUB_SNAPSHOT_SCRIPT, "w", encoding="utf-8") as fh:
            fh.write(script)
        os.chmod(GRUB_SNAPSHOT_SCRIPT, 0o755)
        return True
    except OSError:
        return False


def _create_system_snapshot(packages: List[str], action: str,
                            label: str = "") -> Optional[dict]:
    """Tworzy snapshot root (btrfs) i zapisuje go w bazie.

    Zwraca dict snapshotu albo None. Nie przerywa instalacji – o tym decyduje
    wywołujący (tryb --snapshot wymaga sukcesu, tryb auto tylko ostrzega).
    """
    ok, why = _snapshot_support()
    if not ok:
        return None
    btrfs = _btrfs_bin()
    try:
        os.makedirs(SNAPSHOTS_DIR, exist_ok=True)
    except OSError as e:
        print(_('  ⚠ Cannot create {arg1}: {arg2}', arg1=(SNAPSHOTS_DIR), arg2=(e)), file=sys.stderr)
        return None

    base_id = datetime.now().strftime("%Y%m%dT%H%M%S")
    snap_id = base_id
    n = 1
    while os.path.lexists(os.path.join(SNAPSHOTS_DIR, snap_id)):
        snap_id = f"{base_id}-{n}"
        n += 1
    snap_path = os.path.join(SNAPSHOTS_DIR, snap_id)

    try:
        r = subprocess.run([btrfs, "subvolume", "snapshot", "/", snap_path],
                           capture_output=True, text=True, timeout=600)
    except Exception as e:
        print(_('  ⚠ Failed to create snapshot: {arg1}', arg1=(e)), file=sys.stderr)
        return None
    if r.returncode != 0:
        msg = (r.stderr or r.stdout or "").strip().splitlines()
        print(_('  ⚠ btrfs snapshot failed: {arg1}', arg1=(msg[-1] if msg else r.returncode)),
              file=sys.stderr)
        return None

    rootp = _btrfs_root_path()
    if rootp in ("", "/"):
        subvol = f"/.pag_snapshots/{snap_id}"
    else:
        subvol = f"{rootp}/.pag_snapshots/{snap_id}"

    # Zapamiętaj jądro/initramfs z chwili snapshotu – przy osobnym /boot
    # dzięki temu uruchomimy migawkę ze STARYM (działającym) jądrem.
    _kn, _ir = _pick_kernel_initrd("/boot")
    snap = {
        "id": snap_id,
        "path": snap_path,
        "subvol": subvol,
        "created": datetime.now().isoformat(),
        "action": action,
        "label": label,
        "packages": list(packages)[:100],
        "kernel": _kn,
        "initrd": _ir,
    }
    items = _load_snapshots()
    items.append(snap)
    _save_snapshots(items)
    _ensure_snapshot_grub_script()
    print(_('  📸 System snapshot: {arg1} (subvol={arg2})', arg1=(snap_id), arg2=(subvol)))
    return snap


def _find_snapshot(snap_id: str) -> Optional[dict]:
    items = _load_snapshots()
    if not snap_id:
        return items[-1] if items else None
    for s in items:
        if s.get("id") == snap_id:
            return s
    for s in items:
        if str(s.get("id", "")).startswith(snap_id):
            return s
    return None


def cmd_snapshot_list():
    items = _load_snapshots()
    if not items:
        print(_("snapshot_none"))
        return 0
    print(_("snapshot_list", len(items)))
    for s in reversed(items):
        pkgs = list(s.get("packages") or [])
        listed = ", ".join(pkgs[:4])
        if len(pkgs) > 4:
            listed += f" +{len(pkgs) - 4}"
        print(f"  {s.get('id', '?')}  [{_action_label(s.get('action', ''))}]")
        if listed:
            print(f"     {listed}")
        print(f"     {s.get('created', '')}")
        print(f"     {s.get('path', '')}")
    return 0


def cmd_snapshot_grub():
    """Wypisuje menuentry dla grub-mkconfig (wywoływane z 40_pagan_snapshots)."""
    for line in _grub_snapshot_entries():
        print(line)
    return 0


def cmd_snapshot_create(label: str = ""):
    ok, why = _snapshot_support()
    if not ok:
        print(f"  ❌ {_('snapshot_unsupported', why)}")
        return 1
    snap = _create_system_snapshot([], "manual", label=label)
    if not snap:
        return 1
    _ensure_snapshot_grub_script()
    _refresh_bootloader()
    print(f"  ✅ {_('snapshot_created', snap['id'])}")
    return 0


def cmd_snapshot_delete(snap_id: str):
    snap = _find_snapshot(snap_id)
    if not snap:
        print(f"  ❌ {_('snapshot_not_found', snap_id)}")
        return 1
    path = snap.get("path") or ""
    if not path.startswith(SNAPSHOTS_DIR + "/"):
        print(_('  ❌ Invalid snapshot path – refusing to delete.'))
        return 1
    if os.path.isdir(path):
        btrfs = _btrfs_bin()
        if not btrfs:
            print(f"  ❌ {_('snapshot_unsupported', 'brak btrfs')}")
            return 1
        r = subprocess.run([btrfs, "subvolume", "delete", path],
                           capture_output=True, text=True, timeout=120)
        if r.returncode != 0:
            print(f"  ❌ btrfs: {(r.stderr or '').strip()[:200]}")
            return 1
    _save_snapshots([s for s in _load_snapshots() if s.get("id") != snap.get("id")])
    _refresh_bootloader()
    print(f"  ✅ {_('snapshot_deleted', snap.get('id', ''))}")
    return 0


def cmd_snapshot_rollback(snap_id: str = ""):
    """Ustawia snapshot jako następny start (albo pokazuje wybór w GRUB)."""
    snap = _find_snapshot(snap_id)
    if not snap:
        print(f"  ❌ {_('snapshot_not_found', snap_id or '(brak)' )}")
        return 1
    if not os.path.isdir(snap.get("path") or ""):
        print(f"  ❌ {_('snapshot_not_found', snap.get('id', ''))}")
        return 1

    label = _snapshot_label(snap)
    print(_('  ⏪ Snapshot: {arg1}', arg1=(snap.get('id', ''))))
    print(f"     {snap.get('created', '')}")
    pkgs = list(snap.get("packages") or [])
    if pkgs:
        print(f"     {', '.join(pkgs[:8])}{' …' if len(pkgs) > 8 else ''}")
    if not _ask_confirm():
        return 0

    _ensure_snapshot_grub_script()
    _refresh_bootloader()

    grub_reboot = shutil.which("grub-reboot") or shutil.which("grub2-reboot")
    if grub_reboot:
        r = subprocess.run([grub_reboot, label], capture_output=True, text=True)
        if r.returncode == 0:
            print(f"  ✅ {_('snapshot_rollback_next', label)}")
            print(_('  💡 Reboot the system – GRUB will boot the selected snapshot.'))
            return 0
    print(f"  ℹ {_('snapshot_rollback_hint', label)}")
    print(_('  💡 At boot, choose an entry in the GRUB menu (snapshots section).'))
    return 0


DEFAULT_REPOS = [
    "https://repo.paganlinux.eu/stable/",
]

# =============================================================================
# INICJALIZACJA
# =============================================================================

def _require_dir(d: str) -> None:
    """Utwórz katalog, a przy istniejącej NIE-katalogowej ścieżce podaj powód.

    `os.makedirs(..., exist_ok=True)` nie wystarcza: gdy `mkdir` zwróci EEXIST,
    Python sprawdza `os.path.isdir(path)`, a dla MARTWEGO dowiązania to False –
    wyjątek leci dalej. Objaw: `pag update` kończył się tracebackiem
    `FileExistsError: /var/cache/pag -> /home/pagan-build/cache-pag` (cel
    dowiązania został skasowany).
    """
    try:
        os.makedirs(d, exist_ok=True)
        return
    except FileExistsError:
        pass
    except OSError as e:
        print(f"❌ Nie mogę utworzyć {d}: {e}")
        sys.exit(1)
    if os.path.islink(d) and not os.path.exists(d):
        print(f"❌ {d} jest martwym dowiązaniem → {os.readlink(d)}")
        print(f"   Usuń dowiązanie (rm {d}) albo utwórz katalog docelowy.")
    else:
        print(f"❌ {d} istnieje, ale nie jest katalogiem.")
    sys.exit(1)


def ensure_dirs():
    for d in [PAG_DB, PAG_CACHE, PAG_CONF, REPO_CACHE, REPOS_DIR, STAGING_DIR, DEPLOYMENTS_DIR]:
        _require_dir(d)
    for f, default in [
        (REPOS_CONF, "\n".join(DEFAULT_REPOS) + "\n"),
        (INSTALLED_DB, "{}"),
        (PINNED_FILE, "{}"),
        (HISTORY_FILE, "[]"),
    ]:
        if not os.path.exists(f):
            with open(f, "w") as fh: fh.write(default)
    if not os.path.exists(WORLD_FILE):
        Path(WORLD_FILE).touch()
    if not os.path.exists(GPG_HOME):
        os.makedirs(GPG_HOME, exist_ok=True)
        os.chmod(GPG_HOME, 0o700)
        _gpg_run("--list-keys", capture_output=True)
    # Inicjalizuj SQLite
    _db_init()
    # Wyczyść staging po poprzednim przerwanym buildzie/instalacji
    if os.path.isdir(STAGING_DIR):
        for entry in os.listdir(STAGING_DIR):
            if entry == "backups":
                continue  # backupy starych wersji – potrzebne do `pag rollback`
            path = os.path.join(STAGING_DIR, entry)
            try:
                if os.path.isfile(path) or os.path.islink(path):
                    os.unlink(path)
                elif os.path.isdir(path):
                    shutil.rmtree(path, ignore_errors=True)
            except OSError:
                pass

# =============================================================================
# SQLITE – BAZA PLIKÓW (poprawne zarządzanie połączeniami)
# =============================================================================

from contextlib import contextmanager

@contextmanager
def _db_session(readonly: Optional[bool] = None):
    """Context manager – gwarantuje zamknięcie połączenia.

    Gdy katalog bazy nie jest zapisywalny (np. komenda read-only uruchomiona
    jako zwykły user), otwieramy połączenie w trybie read-only. Inaczej
    `PRAGMA journal_mode=WAL` próbuje pisać i kończy się błędem
    „attempt to write a readonly database” zamiast zwrócić wynik.
    """
    if readonly is None:
        readonly = not os.access(os.path.dirname(FILES_DB_SQL) or ".", os.W_OK)
    if readonly:
        # Katalog bazy nie jest zapisywalny (np. komenda read-only uruchomiona
        # jako zwykły user). Baza jest w trybie WAL, więc SQLite przy `mode=ro`
        # próbuje utworzyć plik `-shm` w katalogu – bez prawa zapisu kończy się
        # to błędem „attempt to write a readonly database” nawet przy SELECT.
        # Dlatego próbujemy zwykłego `mode=ro`, a gdy zawiedzie, otwieramy z
        # `immutable=1` (SQLite pomija wtedy WAL/SHM i czyta ostatni
        # checkpoint). Przy równoległym zapisie roota odczyt może być chwilowo
        # nieaktualny – dla komend diagnostycznych (files/list/verify) to OK.
        conn = sqlite3.connect(f"file:{FILES_DB_SQL}?mode=ro", uri=True, timeout=15)
        try:
            conn.execute("SELECT 1 FROM sqlite_master LIMIT 1")
        except sqlite3.OperationalError:
            conn.close()
            conn = sqlite3.connect(
                f"file:{FILES_DB_SQL}?mode=ro&immutable=1", uri=True, timeout=15)
    else:
        conn = sqlite3.connect(FILES_DB_SQL, timeout=15)
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("PRAGMA synchronous=NORMAL")
    conn.execute("PRAGMA foreign_keys=ON")
    conn.execute("PRAGMA busy_timeout=15000")
    conn.row_factory = sqlite3.Row
    try:
        yield conn
        if not readonly:
            conn.commit()
    except Exception:
        if not readonly:
            conn.rollback()
        raise
    finally:
        conn.close()


def _db_init():
    """Tworzy tabele SQLite jeśli nie istnieją."""
    with _db_session() as db:
        db.execute("""
            CREATE TABLE IF NOT EXISTS files (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                path TEXT NOT NULL,
                package TEXT NOT NULL,
                sha256 TEXT,
                size INTEGER,
                is_symlink INTEGER DEFAULT 0,
                symlink_target TEXT,
                UNIQUE(path, package)
            )
        """)
        db.execute("CREATE INDEX IF NOT EXISTS idx_files_path ON files(path)")
        db.execute("CREATE INDEX IF NOT EXISTS idx_files_pkg ON files(package)")
        db.execute("""
            CREATE TABLE IF NOT EXISTS file_checksums (
                path TEXT PRIMARY KEY,
                sha256 TEXT NOT NULL,
                installed_at TEXT
            )
        """)
        db.commit()

def _db_record_files(pkg_name: str, files: List[dict]):
    """Zapisuje pliki do SQLite (obsługuje symlinki)."""
    with _db_session() as db:
        # Jawna transakcja – atomowość obu zapisów i szybsze wykrycie blokady
        try:
            db.execute("BEGIN IMMEDIATE")
        except sqlite3.OperationalError:
            pass  # transakcja już otwarta (implicit)
        db.executemany(
            "INSERT OR REPLACE INTO files (path, package, sha256, size, is_symlink, symlink_target) "
            "VALUES (?,?,?,?,?,?)",
            [(f["path"], pkg_name, f.get("sha256",""), f.get("size",0),
              f.get("is_symlink", 0), f.get("symlink_target", ""))
             for f in files]
        )
        db.executemany(
            "INSERT OR REPLACE INTO file_checksums (path, sha256, installed_at) VALUES (?,?,?)",
            [(f["path"], f.get("sha256",""), datetime.now().isoformat())
             for f in files if f.get("sha256")]
        )

def _db_get_package_files(pkg_name: str) -> List[str]:
    with _db_session() as db:
        return [r["path"] for r in db.execute(
            "SELECT DISTINCT path FROM files WHERE package=?", (pkg_name,)
        )]

def _db_get_file_owners(filepath: str) -> List[str]:
    """Zwraca listę pakietów będących właścicielami pliku."""
    with _db_session() as db:
        return [r["package"] for r in db.execute(
            "SELECT package FROM files WHERE path=?", (filepath,)
        )]

def _db_remove_package_files(pkg_name: str):
    with _db_session() as db:
        db.execute("DELETE FROM files WHERE package=?", (pkg_name,))
        db.commit()

def _db_get_all_file_checksums() -> Dict[str, str]:
    with _db_session() as db:
        return {r["path"]: r["sha256"] for r in db.execute("SELECT path, sha256 FROM file_checksums")}

def _db_get_package_checksums(pkg_name: str) -> Dict[str, str]:
    """Sumy SHA256 zapisane dla plików należących do pakietu.

    Używane do wykrycia, czy użytkownik zmodyfikował plik konfiguracyjny
    (porównanie z sumą z chwili instalacji) – serce mechanizmu .pacnew/.pacsave.
    """
    with _db_session() as db:
        return {r["path"]: r["sha256"] for r in db.execute(
            "SELECT fc.path AS path, fc.sha256 AS sha256 FROM file_checksums fc "
            "JOIN files f ON f.path = fc.path WHERE f.package=?", (pkg_name,))}


def _db_count_files() -> int:
    with _db_session() as db:
        return db.execute("SELECT COUNT(*) FROM files").fetchone()[0]

# =============================================================================
# BLOKADA
# =============================================================================

class DatabaseLock:
    """Blokada plikowa (flock) – jądro zwalnia ją AUTOMATYCZNIE, gdy proces
    ginie (kill -9, twardy reset). Stary PID-file miał race condition: po
    śmierci pag PID mógł zostać przydzielony obcemu procesowi (PID reuse)
    i pag odmawiał działania na zawsze („baza zablokowana”).
    """
    def __init__(self):
        self._f = None
    def __enter__(self):
        os.makedirs(os.path.dirname(LOCK_FILE), exist_ok=True)
        self._f = open(LOCK_FILE, "w")
        try:
            # LOCK_NB: rzuca wyjątek zamiast czekać w nieskończoność
            fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError:
            print(f"❌ {_('db_locked')}", file=sys.stderr)
            print(f"   {_('db_lock_hint', LOCK_FILE)}", file=sys.stderr)
            sys.exit(1)
        self._f.write(str(os.getpid()))
        self._f.flush()
        return self
    def __exit__(self, *args):
        if self._f:
            try:
                fcntl.flock(self._f, fcntl.LOCK_UN)
            except OSError:
                pass
            self._f.close()
            self._f = None
            # Uwaga: NIE usuwamy pliku blokady. Stały plik + flock na inode to jedyny
            # bezpieczny wzorzec – os.remove(), gdy inny proces trzyma blokadę na starym
            # inode, otwiera wyścig (nowy proces blokowałby nowo utworzony inode).


class SelfUpdateLock:
    """Blokada podmiany binarki pag podczas self-update.

    Niezależna od DatabaseLock (inny plik) – cmd_self_update może zostać
    wywołane poza globalną blokadą (np. z zewnętrznego skryptu), a dwie
    równoległe aktualizacje pisałyby do tego samego `dst.new`; `os.replace`
    mógłby wtedy podmienić plik w trakcie wykonywania (uszkodzony pag).
    """
    def __init__(self):
        self._f = None

    def __enter__(self):
        lock_path = LOCK_FILE + ".self-update"
        os.makedirs(os.path.dirname(lock_path), exist_ok=True)
        self._f = open(lock_path, "w")
        try:
            fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
        except BlockingIOError:
            self._f.close()
            self._f = None
            print(_('❌ Another pag update is in progress – try again later.'),
                  file=sys.stderr)
            sys.exit(1)
        self._f.write(str(os.getpid()))
        self._f.flush()
        return self

    def __exit__(self, *args):
        if self._f:
            try:
                fcntl.flock(self._f, fcntl.LOCK_UN)
            except OSError:
                pass
            self._f.close()
            self._f = None

# =============================================================================
# POMOCNICZE
# =============================================================================


# Katalogi systemowe. /bin, /sbin i /lib64 to na usrmerge symlinki do
# /usr/bin, /usr/bin i /usr/lib64 – bez nich pag pomijał CAŁĄ zawartość
# pakietów, które pakują pliki „starymi” ścieżkami (np. busybox: 386 plików
# w ./bin/, w tym sam ./bin/busybox → "BLOCKED: ./bin/ls" i spółka).
_ALLOWED_PREFIXES = ("/usr/", "/etc/", "/var/", "/opt/",
                     "/boot/", "/lib/", "/lib64/", "/run/",
                     "/bin/", "/sbin/",  # usrmerge: bin→usr/bin, sbin→usr/bin
                     # Pliki wewnętrzne paczki .pkg.tar.xz
                     "metadata.json", "data.tar.xz", "hooks/",
                     "sums.json")

def _check_path_safety(name: str) -> bool:
    # Normalizuj – usuń leading ./
    if name.startswith("./"):
        name = name[2:]
    if name in (".", ""):
        return True
    # Porównuj z prefiksami BEZ wiodącego '/', by zarówno "/usr/bin/ls", jak i
    # wewnętrzne pliki pakietu ("hooks/pre-install", "data.tar.xz") przechodziły.
    norm = name.lstrip("/")
    for prefix in _ALLOWED_PREFIXES:
        p = prefix.lstrip("/").rstrip("/")
        if norm == p or norm.startswith(p + "/"):
            return True
    return False


def _validate_pkg_name(name):
    return bool(ALLOWED_PKG_RE.match(name))



def _audit(msg):
    from datetime import datetime, timezone
    os.makedirs(os.path.dirname(AUDIT_LOG), exist_ok=True)
    with open(AUDIT_LOG, "a") as f:
        f.write(datetime.now(timezone.utc).isoformat() + " " + msg + "\n")

def _strip_suid(path):
    try:
        st = os.stat(path)
        if st.st_mode & 0o4000:
            os.chmod(path, st.st_mode & ~0o4000)
            print(f"  {_("sec_suid", path=path)}")
    except OSError:
        pass

def _check_downgrade(pkg_name, new_ver, installed_db):
    if pkg_name in installed_db:
        old = installed_db[pkg_name].get("version", "0")
        if new_ver < old:
            print(f"  {_("sec_downgrade", pkg=pkg_name, new=new_ver, old=old)}")
            return False
    return True

def _safe_extractall(tar: tarfile.TarFile, dest: str, *, preserve_perms: bool = True,
                     privileged=frozenset()):
    """
    Bezpieczne rozpakowanie archiwum tar z ochroną przed Directory Traversal.

    Działa na Python < 3.12 (gdzie parametr 'filter' w extractall nie istnieje)
    oraz na Python 3.12+. W przeciwieństwie do filtra 'data' z Pythona 3.12,
    zachowuje bity uprawnień POSIX (SUID, SGID, sticky) – preserve_perms=True.

    Ochrona oparta jest na FINALNEJ ścieżce (os.path.realpath), nie tylko na
    prostym sprawdzaniu stringa:
      - Blokuje ścieżki absolutne i z '..' (path traversal)
      - Blokuje symlinki/hardlinki, których cel wychodzi poza dest
      - Blokuje zapis "przez" złośliwy symlink, który został wcześniej
        rozpakowany (np. katalog → /etc, potem zapis katalog/plik)
      - Zachowuje oryginalne uprawnienia plików
    """
    dest_real = os.path.realpath(dest)
    os.makedirs(dest_real, exist_ok=True)

    def _target_within(path: str) -> bool:
        try:
            return os.path.commonpath([dest_real, os.path.realpath(path)]) == dest_real
        except ValueError:
            # różne napędy / ścieżki nie da się wspólnie porównać → odrzuć
            return False

    for member in tar.getmembers():
        name = member.name

        # --- Ochrona przed Directory Traversal (szybkie string-checki) ---
        if name.startswith('/'):
            continue
        if '..' in name.split('/'):
            continue
        # Zablokuj bajt NUL i backslash (bugi/obejścia tarfile na niektórych platformach)
        if '\x00' in name or '\\' in name:
            continue
        if not _check_path_safety(name):
            print(f"  BLOCKED: {name}")
            continue

        target = os.path.join(dest, name)

        # --- Ochrona na podstawie finalnej ścieżki ---
        # Jeśli którykolwiek komponent nadrzędny jest (złośliwym) symlinkiem
        # wskazującym poza dest, realpath to wykryje – zablokuj zapis.
        if not _target_within(target):
            print(f"  BLOCKED (escape): {name}")
            continue

        # --- Ochrona dla symlinków i hardlinków ---
        if member.issym() or member.islnk():
            link = member.linkname
            if '\x00' in link:
                continue
            # Link absolutny jest POPRAWNY, gdy cel jest ścieżką systemową
            # (np. usr/bin/librewolf -> /usr/lib/librewolf/librewolf). Wcześniej
            # odrzucaliśmy wszystkie takie linki po cichu, przez co w systemie
            # brakowalo np. /usr/bin/librewolf — a wpis .desktop z TryExec nie
            # pojawiał się w menu. Odrzucamy tylko cele spoza dozwolonych prefiksów.
            if link.startswith('/'):
                if not _check_path_safety(link):
                    print(f"  BLOCKED (link target): {name} -> {link}")
                    continue
                # Cel absolutny zostaje bez zmian – po instalacji wskazuje
                # właściwą ścieżkę w systemie (sprawdzenie _target_within
                # dotyczy ścieżki RELATYWNEJ i tutaj nie ma zastosowania).
            else:
                # UWAGA: '..' w relatywnym celu linku jest POPRAWNE i częste
                # (np. busybox: bin/ls -> ../usr/bin/busybox). Wcześniej taki
                # link byl po cichu pomijany, przez co busybox instalowal
                # 3 pliki zamiast 388. Decyduje realny cel — _target_within().
                link_target = os.path.join(os.path.dirname(target), link)
                if not _target_within(link_target):
                    print(f"  BLOCKED (link escape): {name} -> {link}")
                    continue

        # Rozpakuj z zachowaniem metadanych. Python 3.12+ wymaga jawnego
        # `filter=` (inaczej DeprecationWarning, a w 3.14+ błąd).
        # UWAGA: 'fully_trusted' CELOWO pomija wbudowane filtry bezpieczeństwa
        # Pythona – to nie przeoczenie. Nasza walidacja powyżej (path traversal,
        # NUL/backslash, escape przez symlink, linki wychodzące poza dest) jest
        # równoważna lub ostrzejsza, a 'fully_trusted' pozwala zachować bity
        # SUID/SGID/sticky, które filtr 'data' by usunął (np. /usr/bin/sudo).
        # SUID jest i tak zdejmowany przez _strip_suid() tuż po rozpakowaniu.
        try:
            if hasattr(tarfile, 'data_filter'):
                # Python 3.12+
                tar.extract(member, dest, set_attrs=preserve_perms, numeric_owner=False,
                            filter='fully_trusted')
            else:
                tar.extract(member, dest, set_attrs=preserve_perms, numeric_owner=False)
        except Exception as e:
            print(_('  ⚠ Failed to extract {arg1}: {arg2}', arg1=(name), arg2=(e)))
            continue
        # Pliki z listy uprzywilejowanej zachowują SUID/SGID; reszta jest
        # czyszczona (ochrona przed SUID niespodziewanym w pakiecie).
        if "/" + os.path.relpath(target, dest_real) not in privileged:
            _strip_suid(target)


def _sha256_file(path: str) -> str:
    """SHA256 pliku. Na Python ≥3.11 używa hashlib.file_digest (pętla w C);
    starsze wersje mają fallback z pętlą chunków."""
    with open(path, "rb") as f:
        if hasattr(hashlib, "file_digest"):
            return hashlib.file_digest(f, "sha256").hexdigest()
        h = hashlib.sha256()
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
        return h.hexdigest()

def _split_version(v: str):
    """Rozdziela wersję na (release_parts, prerelease_parts).

    Przykład: '1.2.0-rc1' → ([1,2,0], ['rc','1']).
    """
    v = v.strip().lower().lstrip("v")
    # build metadata po '+' jest ignorowane przy porównywaniu (semver)
    v = v.split("+", 1)[0]
    # prerelease po '-' lub '_' (np. 1.2.0-rc1, 1.2.0_rc1)
    if "-" in v:
        rel, pre = v.split("-", 1)
    elif "_" in v:
        rel, pre = v.split("_", 1)
    else:
        rel, pre = v, ""
    nums = []
    for part in rel.split("."):
        m = re.match(r"(\d+)", part)
        nums.append(int(m.group(1)) if m else 0)
    pre_parts = [p for p in pre.split(".") if p]
    return nums, pre_parts


def _cmp_pre(a, b):
    """Porównuje ciągi identyfikatorów prerelease (reguły semver)."""
    for i in range(max(len(a), len(b))):
        if i >= len(a):
            return -1  # krótszy prerelease jest niższy
        if i >= len(b):
            return 1
        ia, ib = a[i], b[i]
        if ia == ib:
            continue
        na, nb = ia.isdigit(), ib.isdigit()
        if na and nb:
            return 1 if int(ia) > int(ib) else -1
        if na != nb:
            return -1 if na else 1  # identyfikator liczbowy < alfanumeryczny
        return 1 if ia > ib else -1
    return 0


def _cmp_version(a: str, b: str) -> int:
    """Porównuje dwie wersje; zwraca -1/0/1. Obsługuje prerelease (rc1, beta...)."""
    a_rel, a_pre = _split_version(a)
    b_rel, b_pre = _split_version(b)
    # Porównaj część release (brakujące komponenty traktuj jako 0)
    for i in range(max(len(a_rel), len(b_rel))):
        xa = a_rel[i] if i < len(a_rel) else 0
        xb = b_rel[i] if i < len(b_rel) else 0
        if xa != xb:
            return 1 if xa > xb else -1
    # Część release równa → decyduje prerelease.
    # Wersja finalna (bez prerelease) jest ZAWSZE nowsza od prerelease.
    if not a_pre and not b_pre:
        return 0
    if not a_pre:
        return 1
    if not b_pre:
        return -1
    return _cmp_pre(a_pre, b_pre)


def _version_newer(a: str, b: str) -> bool:
    """True gdy wersja a jest nowsza od b (z poprawną obsługą prerelease)."""
    try:
        return _cmp_version(a, b) > 0
    except Exception:
        return a != b

def load_json(path):
    try:
        with open(path) as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return {}

def save_json(path, data):
    with open(path, "w") as f:
        json.dump(data, f, indent=2)

class PackageInfo:
    __slots__ = ("name","version","release","description","dependencies",
                 "optdepends","size_bytes","sha256","gpg_fp","repo_url","filename",
                 "provides","license","provides_so","requires_so","privileged")
    def __init__(self, d, repo=""):
        self.name = d.get("name","?")
        self.version = d.get("version","0")
        self.release = d.get("release", 1)
        self.description = d.get("description","")
        self.dependencies = d.get("dependencies", d.get("depends", []))
        # Opcjonalne zależności (flatpak, btrfs-progs, grub, ...) – tylko
        # informacyjne; `pag install` NIE instaluje ich automatycznie.
        self.optdepends = d.get("optdepends", []) or []
        self.size_bytes = d.get("size",0)
        self.sha256 = d.get("sha256","")
        self.gpg_fp = d.get("gpg_fingerprint","")
        self.repo_url = repo
        self.filename = d.get("filename", f"{self.name}-{self.version}{PKG_EXT}")
        self.provides = d.get("provides", []) or []
        self.license = d.get("license", []) or []
        self.provides_so = d.get("provides_so", []) or []
        self.requires_so = d.get("requires_so", []) or []
        # Ścieżki, którym wolno zachować setuid/setgid i grupę (z receptury).
        self.privileged = d.get("privileged", []) or []

# =============================================================================
# REPOZYTORIA (cache, ETag, GPG)
# =============================================================================

def _parse_repos_config():
    """Parsuje repozytoria z /etc/pag/repos.conf oraz /etc/pag/repos/*.conf.

    Format linii: <url> [fingerprint]
    Opcjonalny `fingerprint` (40 znaków hex) pozwala przypiąć klucz
    podpisujący repo do konkretnego adresu – wtedy TOFU (auto-zaufanie przy
    pierwszym użyciu) nie jest potrzebne, a zmiana klucza = błąd bezpieczeństwa.

    Drop-iny (np. stable.conf) są czytane alfabetycznie – pozwalają na
    wygodne dodawanie repo bez dotykania głównego repos.conf
    (np. `echo 'https://repo.paganlinux.eu/stable' > /etc/pag/repos/stable.conf`).
    """
    entries = []

    def _read_lines(path):
        if not os.path.exists(path):
            return
        for line in open(path):
            line = line.strip()
            if not line or line.startswith("#"):
                continue
            parts = line.split()
            url = parts[0].rstrip("/")
            fp = parts[1].lower() if len(parts) > 1 else ""
            entries.append({"url": url, "fingerprint": fp or None})

    # 1) Legacy: pojedynczy plik /etc/pag/repos.conf
    _read_lines(REPOS_CONF)
    # 2) Drop-in: /etc/pag/repos/<nazwa>.conf (sortowane, stabilna kolejność)
    if os.path.isdir(REPOS_DIR):
        for drop in sorted(os.listdir(REPOS_DIR)):
            if drop.endswith(".conf"):
                _read_lines(os.path.join(REPOS_DIR, drop))

    # Dedupe po URL (zachowaj pierwszy wpis – może mieć fingerprint)
    seen, unique = set(), []
    for e in entries:
        if e["url"] not in seen:
            seen.add(e["url"])
            unique.append(e)

    if not unique:
        for url in DEFAULT_REPOS:
            # rstrip: get_repos()/_repo_pinned_fp() kluczują URL-e bez ukośnika
            unique.append({"url": url.rstrip("/"), "fingerprint": None})
    return unique


def get_repos():
    return [e["url"] for e in _parse_repos_config()]


def _repo_pinned_fp(repo_url):
    """Zwraca przypięty fingerprint klucza dla repo (z konfiguracji lub trust DB)."""
    # Normalizacja ukośnika: _parse_repos_config() i trust DB kluczują URL-e BEZ
    # końcowego „/”, a wywołujący podają często DEFAULT_REPOS[0] Z ukośnikiem.
    # Bez tego przypięty klucz nie był znajdowany i lokalny .pag dostawał
    # fałszywe „Brak przypiętego klucza repo” mimo poprawnego wpisu w trusted.json.
    repo_url = repo_url.rstrip("/")
    by_url = {e["url"]: e["fingerprint"] for e in _parse_repos_config()}
    if by_url.get(repo_url):
        return by_url[repo_url]
    db = _load_trust_db()
    fp = db.get(repo_url)
    return fp.lower() if fp else None

def _repo_cache_path(url):
    return os.path.join(REPO_CACHE, url.replace("://","_").replace("/","_").replace(".","_") + ".json")

def _repo_etag_path(url): return _repo_cache_path(url) + ".etag"
def _repo_ts_path(url): return _repo_cache_path(url) + ".ts"

# Informacja (raz na uruchomienie), gdy cache repozytoriów jest tylko-do-odczytu –
# np. komendy read-only (`pag info`, `pag search`…) jako zwykły user: nie ma sensu
# ani prawa odświeżać /var/cache/pag/repos, więc używamy lokalnej kopii indeksu.
_cache_ro_notice_done = False

def _cache_ro_notice():
    global _cache_ro_notice_done
    if _cache_ro_notice_done:
        return
    _cache_ro_notice_done = True
    print(f"  ⚠ {_('cache_ro', cache=REPO_CACHE)}", file=sys.stderr)

def _load_repo_cache(cp: str) -> Optional[list]:
    """Wczytuje cache indeksu repo; zwraca None gdy brak albo uszkodzony.

    Partial write (crash w trakcie zapisu) mógł zostawić obcięty JSON. Zamiast
    zwracać pustą listę pakietów (użytkownik myśli, że repo jest puste)
    sygnalizujemy None – wywołujący ponowi pobranie albo pokaże ostrzeżenie."""
    if not os.path.exists(cp):
        return None
    try:
        with open(cp, "r", encoding="utf-8") as fh:
            data = json.load(fh)
        pkgs = data.get("packages")
        if not isinstance(pkgs, list):
            raise ValueError(_("repo_index_invalid"))
        return pkgs
    except (OSError, ValueError) as e:
        print(_('  ⚠ Corrupted index cache {arg1}: {arg2}', arg1=(cp), arg2=(e)), file=sys.stderr)
        return None


def fetch_repo_index(repo_url, force=False):
    cp = _repo_cache_path(repo_url)
    ep = _repo_etag_path(repo_url)
    tp = _repo_ts_path(repo_url)

    if not force and os.path.exists(cp) and os.path.exists(tp):
        try:
            if time.time() - float(open(tp).read().strip()) < REPO_CACHE_TTL:
                cached = _load_repo_cache(cp)
                if cached is not None:
                    return cached
                # uszkodzony cache – spróbuj odświeżyć z sieci
        except (OSError, ValueError):
            pass

    # --- Cache tylko-do-odczytu (np. `pag info` jako zwykły user) ---
    # /var/cache/pag/repos należy do roota. Nie próbuj odświeżać ani pisać –
    # zwykły user i tak nie zapisze indeksu; użyj lokalnej kopii (może być
    # nieaktualna). Pełne odświeżenie indeksu: sudo pag sync
    if not (os.path.isdir(REPO_CACHE) and os.access(REPO_CACHE, os.W_OK)):
        if force:
            print(_('  ❌ {arg1}: cannot refresh index – {arg2} is read-only', arg1=(repo_url), arg2=(REPO_CACHE)),
                  file=sys.stderr)
            return None
        _cache_ro_notice()
        cached = _load_repo_cache(cp)
        if cached is not None:
            return cached
        return None

    headers = {"User-Agent": "pag/3.0"}
    if os.path.exists(tp) and not force:
        try:
            lm = datetime.fromtimestamp(float(open(tp).read().strip()), tz=timezone.utc)
            # Wymuś lokalizację C/POSIX dla nagłówków HTTP, aby unikać problemów z nazwami dni/miesięcy
            try:
                old_locale = locale.setlocale(locale.LC_TIME)
                locale.setlocale(locale.LC_TIME, 'C')
                headers["If-Modified-Since"] = lm.strftime("%a, %d %b %Y %H:%M:%S GMT")
                locale.setlocale(locale.LC_TIME, old_locale)
            except (locale.Error, ValueError):
                # Jeśli ustawienie lokalizacji się nie powiedzie, użyj domyślnej
                headers["If-Modified-Since"] = lm.strftime("%a, %d %b %Y %H:%M:%S GMT")
        except: pass
    if os.path.exists(ep) and not force:
        try: headers["If-None-Match"] = open(ep).read().strip()
        except: pass

    # --- Pobranie indeksu (błędy SIECI nie są błędami zapisu cache) ---
    try:
        req = Request(f"{repo_url}/repo.json", headers=headers)
        with urlopen(req, timeout=30) as resp:
            etag = resp.headers.get("ETag","")
            raw = resp.read()
        data = json.loads(raw.decode())
    except HTTPError as e:
        if e.code == 304:
            # Serwer: indeks bez zmian – odśwież tylko znacznik czasu (best-effort)
            try:
                open(tp,"w").write(str(time.time()))
            except OSError:
                pass
            cached = _load_repo_cache(cp)
            if cached is not None:
                return cached
            # uszkodzona kopia – potraktuj jak brak (ostrzeżenie niżej)
        print(_('  ⚠ HTTP {arg1} for {arg2}', arg1=(e.code), arg2=(repo_url)), file=sys.stderr)
        return None
    except Exception as e:
        print(_('  ⚠ Failed to download index {arg1}: {arg2}', arg1=(repo_url), arg2=(e)), file=sys.stderr)
        return _load_repo_cache(cp)

    # Indeks pobrany – zapisz SUROWE bajty (nie re-serializuj! podpis GPG jest
    # nad oryginalnymi bajtami repo.json z serwera) i zweryfikuj podpis.
    # Najpierw zapis tymczasowy + weryfikacja GPG, dopiero potem podmiana cp:
    # błąd zapisu (np. pełny dysk) nie niszczy starej, zweryfikowanej kopii
    # i NIGDY nie zwracamy danych, które nie przeszły weryfikacji.
    tmp_path = cp + ".tmp"
    try:
        with open(tmp_path, "wb") as f:
            f.write(raw)
        if not _verify_repo_sig(repo_url, tmp_path):
            return None  # weryfikacja nie powiodła się – stary cache zostaje
        os.replace(tmp_path, cp)
        # przenieś podpis obok docelowego pliku (marker „repo ma podpis")
        for _ext in (".asc", ".sig"):
            if os.path.exists(tmp_path + _ext):
                try:
                    os.replace(tmp_path + _ext, cp + _ext)
                except OSError:
                    pass
                break
        if etag:
            try:
                open(ep,"w").write(etag)
            except OSError:
                pass
        try:
            open(tp,"w").write(str(time.time()))
        except OSError:
            pass
        return data.get("packages",[])
    except OSError as e:
        print(_('  ⚠ Index downloaded, but failed to save cache ({arg1}): {arg2}', arg1=(REPO_CACHE), arg2=(e)),
              file=sys.stderr)
        # cp nie został podmieniony (podmiana jest po weryfikacji) – lokalna kopia
        # to wciąż stare, zweryfikowane dane
        return _load_repo_cache(cp)
    finally:
        for _p in (tmp_path, tmp_path + ".asc", tmp_path + ".sig"):
            try:
                os.unlink(_p)
            except OSError:
                pass

def _verify_repo_sig(repo_url, cache_path) -> bool:
    """Weryfikuje podpis GPG indeksu repozytorium i przypina fingerprint.

    FAIL-CLOSED: brak/nieprawidłowy podpis = False (chyba że PAG_INSECURE=1).
    Zwraca True jeśli indeks jest zaufany, False jeśli należy go odrzucić.

    Model zaufania (TOFU + pinning):
      - Pierwszy raz (brak przypiętego fingerprintu) → klucz jest importowany,
        a fingerprint zapisywany w /etc/pag/trusted.json z JAWNYM ostrzeżeniem.
        To świadomy kompromis wygody i bezpieczeństwa.
      - Kolejne uruchomienia: fingerprint jest porównywany z przypiętym.
        Zmiana klucza = ❌ SECURITY ERROR (fail-closed), wymagane ręczne:
          pag key-trust <repo_url>  (po weryfikacji nowego klucza)
    """
    insecure = os.environ.get("PAG_INSECURE", "") == "1"

    if not os.path.exists(GPG_HOME):
        if insecure:
            return True  # brak GPG home – tryb insecure, akceptuj
        print(_('  ❌ {arg1}: no GPG keys – verification impossible!', arg1=(repo_url)))
        print(_('     Set PAG_INSECURE=1 to skip (not recommended)'))
        os.remove(cache_path)
        return False

    sig_path = cache_path + ".sig"
    # Podpisy generowane jako .asc (armored) – próbuj .asc, potem .sig
    sig_data = None
    sig_ext = ""
    for ext in (".asc", ".sig"):
        try:
            req = Request(f"{repo_url}/repo.json{ext}", headers={"User-Agent":"pag/3.0"})
            with urlopen(req, timeout=15) as resp:
                sig_data = resp.read()
            sig_ext = ext
            break
        except Exception:
            continue
    if not sig_data:
        if insecure:
            return True  # tryb insecure – akceptuj bez podpisu
        print(_('  ❌ {arg1}: CANNOT DOWNLOAD SIGNATURE repo.json.asc/.sig!', arg1=(repo_url)))
        print(_('     Set PAG_INSECURE=1 to skip (not recommended)'))
        os.remove(cache_path)
        return False
    sig_path = cache_path + sig_ext
    with open(sig_path, "wb") as f:
        f.write(sig_data)

    ok, fingerprint = _gpg_verify_fp(sig_path, cache_path)
    if not ok:
        # Automatyczny import klucza repo przy pierwszym uruchomieniu (TOFU,
        # jak apt) – gdy w keyringu brakuje klucza (No public key).
        res = _gpg_run("--verify", sig_path, cache_path,
                       capture_output=True, text=True, timeout=30)
        _stderr = res.stderr.decode(errors="replace") if isinstance(res.stderr, bytes) else (res.stderr or "")
        if "public key" in _stderr.lower() and "no public key" in _stderr.lower():
            try:
                with urlopen(Request(f"{repo_url}/paganos.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
                    keydata = r.read()
                with tempfile.NamedTemporaryFile(delete=False, suffix=".asc") as tmp:
                    tmp.write(keydata)
                    tmp.flush()
                    _gpg_run("--import", tmp.name, capture_output=True, timeout=30)
                    os.unlink(tmp.name)
                print(_('  🔑 Imported repo key from {arg1}/paganos.asc', arg1=(repo_url)))
                ok, fingerprint = _gpg_verify_fp(sig_path, cache_path)
            except Exception:
                pass
        if not ok:
            if insecure:
                print(_('  ⚠ {arg1}: invalid GPG signature (PAG_INSECURE – ignoring)', arg1=(repo_url)))
                return True
            os.remove(cache_path)
            if not shutil.which(GPG_BINARY):
                print(_('  ❌ {arg1}: GPG is not installed – cannot verify the signature!', arg1=(repo_url)))
                print(_('     Install gnupg or set PAG_INSECURE=1 (not recommended)'))
            else:
                print(_('  ❌ {arg1}: INVALID GPG SIGNATURE of the repository index!', arg1=(repo_url)))
            return False

    # --- Wymuś przypięty fingerprint (TOFU + pinning) ---
    pinned = _repo_pinned_fp(repo_url)
    if pinned:
        if not fingerprint:
            if insecure:
                print(_('  ⚠ {arg1}: cannot read signature fingerprint (PAG_INSECURE – ignoring)', arg1=(repo_url)))
                return True
            os.remove(cache_path)
            print(_('  ❌ [SECURITY ERROR] {arg1}: cannot read signature fingerprint!', arg1=(repo_url)))
            print(_('     Pinned key: {arg1} – rejecting the index.', arg1=(pinned)))
            return False
        if fingerprint != pinned.upper():
            if insecure:
                print(_('  ⚠ {arg1}: SIGNING KEY CHANGED (PAG_INSECURE – ignoring)', arg1=(repo_url)))
                return True
            os.remove(cache_path)
            print(_('  ❌ [SECURITY ERROR] {arg1}: Repository signing key has changed!', arg1=(repo_url)))
            print(_('     Expected: {arg1}', arg1=(pinned)))
            print(_('     Received:  {arg1}', arg1=(fingerprint)))
            print(_('     If this is an intentional key rotation: pag key-trust {arg1}', arg1=(repo_url)))
            return False
        return True

    if fingerprint:
        # Brak przypiętego fingerprintu → TOFU: zapisz go w bazie zaufania.
        db = _load_trust_db()
        if db.get(repo_url) != fingerprint:
            _save_trust_db({**db, repo_url: fingerprint})
            print(_('  🔐 Pinned repo fingerprint {arg1}: {arg2}', arg1=(repo_url), arg2=(fingerprint)))
            print(_('     (TOFU – first trust. If the key changes, pag will refuse updates.)'))
            print(_('     To avoid TOFU, add the fingerprint to /etc/pag/repos.conf.'))
    return True

def fetch_all_packages(force=False):
    all_pkgs = {}
    for repo_url in get_repos():
        pkgs = fetch_repo_index(repo_url, force)
        if pkgs:
            for pdata in pkgs:
                name = pdata.get("name", pdata.get("filename","?").split("-")[0])
                pkg = PackageInfo(pdata, repo_url)
                if name not in all_pkgs or _version_newer(pkg.version, all_pkgs[name].version):
                    all_pkgs[name] = pkg
    return all_pkgs

# =============================================================================
# GPG
# =============================================================================

def _verify_pkg_gpg(pkg_path, repo_url=None):
    """Weryfikuje podpis GPG pakietu i (jeśli znamy repo) przypięty fingerprint.

    FAIL-CLOSED: brak podpisu = odrzucenie (chyba że PAG_INSECURE=1).
    Zwraca (passed: bool, message: str).
    """
    insecure = os.environ.get("PAG_INSECURE", "") == "1"
    # Brak gnupg = weryfikacja niemożliwa. Bez tej gałęzi użytkownik dostawał
    # mylące „NIEPRAWIDŁOWY PODPIS GPG”, mimo że paczka i podpis są w porządku.
    if not shutil.which(GPG_BINARY):
        if insecure:
            return True, "(gpg missing – PAG_INSECURE)"
        return False, _("gpg_missing")
    sig_path = pkg_path + ".sig"
    if not os.path.exists(sig_path) and os.path.exists(pkg_path + ".asc"):
        sig_path = pkg_path + ".asc"

    if not os.path.exists(sig_path):
        if insecure:
            return True, "(no signature – PAG_INSECURE)"
        return False, "BRAK PODPISU – pakiet odrzucony (ustaw PAG_INSECURE=1 aby pominąć)"

    ok, fp = _gpg_verify_fp(sig_path, pkg_path)
    if not ok:
        if insecure:
            return True, "(invalid signature – PAG_INSECURE)"
        return False, "NIEPRAWIDŁOWY PODPIS GPG"

    # Opcjonalnie: sprawdź, czy podpis pochodzi od klucza przypiętego dla repo.
    if repo_url:
        pinned = _repo_pinned_fp(repo_url)
        if pinned and fp and fp != pinned.upper():
            if insecure:
                return True, "(pkg signer mismatch – PAG_INSECURE)"
            return False, f"PAKIET PODPISANY INNYM KLUCZEM niż repo (oczekiwano {pinned})"

    return True, "GPG verified"

def cmd_key_add(source):
    ensure_dirs()
    if not shutil.which(GPG_BINARY):
        print(f"❌ {_('gpg_missing')}"); return 1
    if source.startswith("http"):
        try:
            with urlopen(Request(source, headers={"User-Agent":"pag/3.0"}), timeout=30) as resp:
                keydata = resp.read()
            with tempfile.NamedTemporaryFile(delete=False, suffix=".gpg") as tmp:
                tmp.write(keydata); tmp.flush()
                res = _gpg_run("--import", tmp.name, capture_output=True, timeout=30)
                os.unlink(tmp.name)
            if res.returncode != 0:
                print(f"❌ {_('key_add_failed')}"); return 1
        except Exception as e:
            print(_('❌ Download error: {arg1}', arg1=(e))); return 1
    else:
        res = _gpg_run("--import", source, capture_output=True, timeout=30)
        if res.returncode != 0:
            print(f"❌ {_('key_add_failed')}"); return 1
    print(f"✅ {_('key_imported')}")

def cmd_key_list():
    if not shutil.which(GPG_BINARY):
        print(f"❌ {_('gpg_missing')}"); return
    if not os.path.exists(GPG_HOME):
        print(_("no_keys")); return
    result = _gpg_run("--list-keys", "--keyid-format", "LONG",
                       capture_output=True, text=True, timeout=30)
    if result.returncode != 0:
        print(f"❌ {_('gpg_missing')}"); return
    print(result.stdout or _("no_keys"))

def cmd_key_remove(key_id):
    _gpg_run("--batch", "--yes", "--delete-key", key_id,
              capture_output=True, timeout=30)
    print(f"✅ {_('key_removed', key_id)}")

def _repo_signer_fp(repo_url):
    """Pobiera repo.json + podpis i zwraca fingerprint podpisującego (bez pinningu)."""
    repo_url = repo_url.rstrip("/")
    try:
        with urlopen(Request(f"{repo_url}/repo.json", headers={"User-Agent":"pag/3.0"}), timeout=30) as r:
            data = r.read()
    except Exception:
        return None
    sig = None
    sig_ext = ".asc"
    for ext in (".asc", ".sig"):
        try:
            with urlopen(Request(f"{repo_url}/repo.json{ext}", headers={"User-Agent":"pag/3.0"}), timeout=20) as r:
                sig = r.read()
            sig_ext = ext
            break
        except Exception:
            continue
    if not sig:
        return None
    with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tf:
        tf.write(data); tf.flush()
        data_path = tf.name
    sig_path = data_path + sig_ext
    try:
        with open(sig_path, "wb") as f:
            f.write(sig)
        ok, fp = _gpg_verify_fp(sig_path, data_path)
    finally:
        for p in (data_path, sig_path):
            try: os.unlink(p)
            except OSError: pass
    return fp if ok else None


def cmd_key_trust(repo_url):
    """Przypina fingerprint klucza podpisującego repo (koniec z TOFU dla tego repo)."""
    repo_url = repo_url.rstrip("/")
    print(_('🔐 Pinning repo key {arg1}...', arg1=(repo_url)))
    fp = _repo_signer_fp(repo_url)
    if not fp:
        print(_('  ❌ Cannot read signature fingerprint (missing/failed).'))
        print(_('     Make sure the repo key is in the keyring (pag key-add <url|file>).'))
        return 1
    db = _load_trust_db()
    _save_trust_db({**db, repo_url: fp})
    print(_('  ✅ Pinned {arg1} for {arg2}', arg1=(fp), arg2=(repo_url)))
    print(_('     From now on, a key change will be reported as SECURITY ERROR.'))
    return 0


def cmd_key_untrust(repo_url):
    """Usuwa przypięcie fingerprintu dla repo (wraca do TOFU)."""
    repo_url = repo_url.rstrip("/")
    db = _load_trust_db()
    if repo_url not in db:
        print(_('  ℹ {arg1} has no pinned fingerprint.', arg1=(repo_url)))
        return 0
    del db[repo_url]
    _save_trust_db(db)
    print(_('  ✅ Removed pin for {arg1}.', arg1=(repo_url)))
    return 0


def cmd_key_trusted():
    """Listuje przypięte fingerprinty repozytoriów."""
    db = _load_trust_db()
    if not db:
        print(_("no_keys"))
        return
    for url, fp in sorted(db.items()):
        print(f"  {url}\n      {fp}")

# =============================================================================
# ATOMOWA INSTALACJA (STAGING)
# =============================================================================

def _safe_rename(src: str, dst: str) -> bool:
    """
    Atomowe przeniesienie pliku. Jeśli src i dst są na różnych
    systemach plików (EXDEV), kopiuje + usuwa źródło.
    """
    try:
        os.rename(src, dst)
        return True
    except OSError as e:
        if e.errno == 18:  # EXDEV – cross-device link
            shutil.copy2(src, dst)
            os.remove(src)
            return True
        raise


def _install_file(src: str, rel: str, data_staging: str, sums: dict,
                   staging: str, journal: list, installed_files: list,
                   deploy_dir: str = "", backup_dir: str = "",
                   backup_journal: Optional[list] = None,
                   old_checksums: Optional[dict] = None,
                   privileged=frozenset()) -> bool:
    """
    Instaluje pojedynczy plik (zwykły lub symlink).
    Obsługuje: cross-device rename, symlinki, weryfikację SHA256.

    Jeśli deploy_dir jest podany (tryb immutable), pliki systemowe trafiają
    do deploymentu, a współdzielone (/var, /etc, ...) bezpośrednio do /.

    Jeśli backup_dir jest podany, a pod dst istnieje już plik (upgrade/reinstall),
    stara wersja jest przenoszona do backup_dir, by rollback mógł ją przywrócić.

    old_checksums: {ścieżka: sha256 z chwili instalacji}. Gdy podane i plik /etc
    został zmodyfikowany przez użytkownika, nowa wersja ląduje jako .pacnew
    (stary plik NIE jest ruszany) – wzorzec jak w pacmanie.
    """
    # W trybie immutable: pliki współdzielone idą do /, reszta do deploymentu
    if deploy_dir and _is_shared_path("/" + rel):
        dst_root = PAG_ROOT
    elif deploy_dir:
        dst_root = deploy_dir
    else:
        dst_root = PAG_ROOT

    dst = os.path.join(dst_root, rel)

    # --- SYMLINK ---
    if os.path.islink(src):
        link_target = os.readlink(src)
        # Weryfikuj sums.json dla symlinka (hash ścieżki docelowej)
        expected = sums.get("/" + rel, "")
        if expected:
            link_hash = hashlib.sha256(link_target.encode()).hexdigest()
            if expected and link_hash != expected:
                return False

        os.makedirs(os.path.dirname(dst), exist_ok=True)
        # Backup istniejącego symlinka (upgrade) – dla poprawnego rollbacku
        if backup_dir and backup_journal is not None and os.path.lexists(dst):
            try:
                backup_path = os.path.join(backup_dir, rel)
                os.makedirs(os.path.dirname(backup_path), exist_ok=True)
                os.replace(dst, backup_path)
                backup_journal.append((backup_path, "/" + rel))
                journal.append(("backup", backup_path, dst))
            except OSError:
                pass
        # Jeśli docelowy symlink już istnieje, usuń go
        if os.path.islink(dst) or os.path.exists(dst):
            os.remove(dst)
        os.symlink(link_target, dst)
        journal.append(("symlink", "", dst))
        installed_files.append({
            "path": "/" + rel,
            "sha256": hashlib.sha256(link_target.encode()).hexdigest(),
            "size": len(link_target),
            "is_symlink": True,
            "symlink_target": link_target,
        })
        return True

    # --- ZWYKŁY PLIK ---
    # Oblicz SHA256
    try:
        file_sha = _sha256_file(src)
    except Exception:
        file_sha = ""

    # Weryfikuj sums.json
    expected = sums.get("/" + rel, "")
    if expected and file_sha and file_sha != expected:
        return False

    # --- .pacnew: NIE nadpisuj pliku konfiguracyjnego, którego nie wolno zgubić ---
    # Robimy `<plik>.pacnew`, gdy:
    #   a) plik jest śledzony i użytkownik go zmodyfikował (hash != zapisanej sumy),
    #   b) to wrażliwa konfiguracja (/etc/pam.d, /etc/security, sudoers, shadow…),
    #      a treść na dysku różni się od tej z pakietu – chroni auth przed
    #      cichym nadpisaniem przez `install`/`upgrade` (np. przez shadow).
    # NIE robimy .pacnew, jeśli plik na dysku jest identyczny z nowym albo był
    # niezmieniony od instalacji (wtedy nadpisanie jest bezpieczne).
    old_sha = (old_checksums or {}).get("/" + rel, "")
    if file_sha and _is_config_path(rel) and os.path.isfile(dst) and not os.path.islink(dst):
        tracked_modified = bool(old_sha) and file_sha != old_sha
        if tracked_modified or _is_sensitive_config(rel):
            try:
                cur_sha = _sha256_file(dst)
            except OSError:
                cur_sha = ""
            if cur_sha and cur_sha != file_sha and not (old_sha and cur_sha == old_sha):
                pacnew = dst + ".pacnew"
                try:
                    _safe_rename(src, pacnew)
                    try:
                        os.chown(pacnew, 0, 0)
                    except (OSError, PermissionError):
                        pass
                    # Journal (do cofnięcia przy nieudanej transakcji) – ale NIE
                    # zapisujemy .pacnew w bazie plików: to artefakt użytkownika.
                    journal.append(("file", src, pacnew))
                    print(f"      ⚠ {_('conf_pacnew', path=pacnew)}")
                    return True
                except OSError:
                    pass  # nie udało się – kontynuuj normalną instalację

    # Utwórz katalog docelowy
    os.makedirs(os.path.dirname(dst), exist_ok=True)

    # Backup istniejącego pliku (upgrade) – dla poprawnego rollbacku
    if backup_dir and backup_journal is not None and os.path.lexists(dst):
        try:
            backup_path = os.path.join(backup_dir, rel)
            os.makedirs(os.path.dirname(backup_path), exist_ok=True)
            os.replace(dst, backup_path)
            backup_journal.append((backup_path, "/" + rel))
            journal.append(("backup", backup_path, dst))
        except OSError:
            pass

    # Atomowe przeniesienie (z fallbackiem dla cross-device).
    # Zachowuje bity uprawnień (SUID/SGID/sticky) – NIE używamy filter='data'.
    _safe_rename(src, dst)

    if "/" + rel in privileged:
        # Plik uprzywilejowany: zostaw właściciela, grupę i bity z pakietu
        # (np. sudo 4755 root:root, qemu-bridge-helper 4750 root:kvm).
        try:
            st = os.stat(dst)
            if st.st_mode & 0o6000:
                _audit(f"privileged {dst} mode={oct(st.st_mode & 0o7777)} "
                       f"uid={st.st_uid} gid={st.st_gid}")
        except OSError:
            pass
    else:
        # Wymuś właściciela root:root. UWAGA: os.chown() NIE czyści bitów SUID/SGID.
        try:
            os.chown(dst, 0, 0)
        except (OSError, PermissionError):
            # Na niektórych systemach plików (tmpfs, fat) chown może się nie powieść
            pass

    journal.append(("file", src, dst))
    installed_files.append({
        "path": "/" + rel,
        "sha256": file_sha,
        "size": os.path.getsize(dst),
        "is_symlink": False,
    })
    return True



def _stage_package(pkg_path: str, pkg: PackageInfo) -> Optional[dict]:
    """Rozpakowuje pakiet do stagingu, NIE dotykając systemu.

    Zwraca dict: staging, data, sums, hooks. None przy błędzie.

    To pierwsza faza transakcji grupowej: najpierw przygotowujemy WSZYSTKIE
    pakiety (np. całe GNOME – 50 paczek). Dopiero gdy każda się rozpakuje i
    przejdzie weryfikację SHA256, przechodzimy do fazy commit. Błąd jednej
    paczki nie zostawia więc systemu w połowie instalacji.
    """
    staging = tempfile.mkdtemp(dir=STAGING_DIR, prefix=f".stage-{pkg.name}-")
    try:
        with tarfile.open(pkg_path, "r:xz") as tf:
            _safe_extractall(tf, staging)

        data_tar = os.path.join(staging, "data.tar.xz")
        if not os.path.exists(data_tar):
            raise RuntimeError(_("pkg_missing_data_tar"))

        data_staging = os.path.join(staging, "data")
        os.makedirs(data_staging, exist_ok=True)
        priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
        with tarfile.open(data_tar, "r:xz") as tf:
            _safe_extractall(tf, data_staging, privileged=priv)

        sums_path = os.path.join(data_staging, "sums.json")
        sums = json.load(open(sums_path)) if os.path.exists(sums_path) else {}

        # Weryfikacja SHA256 JUŻ w stagingu – uszkodzona paczka nie dojdzie
        # do fazy commit, więc nie zdąży nadpisać żadnego pliku w systemie.
        _bad: List[str] = []
        for _root, _dirs, _files in os.walk(data_staging):
            for _name in list(_dirs) + _files:
                if _name == "sums.json":
                    continue
                _fp = os.path.join(_root, _name)
                _rel = "/" + os.path.relpath(_fp, data_staging)
                _expected = sums.get(_rel, "")
                if not _expected:
                    continue
                try:
                    if os.path.islink(_fp):
                        _actual = hashlib.sha256(
                            os.readlink(_fp).encode()).hexdigest()
                    elif os.path.isfile(_fp):
                        _actual = _sha256_file(_fp)
                    else:
                        continue
                except OSError:
                    _actual = ""
                if _actual != _expected:
                    _bad.append(_rel)
                    if len(_bad) >= 5:
                        break
            if len(_bad) >= 5:
                break
        if _bad:
            raise RuntimeError(_("pkg_sha_mismatch", ", ".join(_bad[:5])))

        return {
            "staging": staging,
            "data": data_staging,
            "sums": sums,
            "hooks": os.path.join(staging, "hooks"),
        }
    except Exception as e:
        shutil.rmtree(staging, ignore_errors=True)
        print(_('  ❌ {arg1}: preparation stage failed ({arg2})', arg1=(pkg.name), arg2=(e)))
        return None


def _discard_staged(staged: Optional[dict]):
    """Usuwa katalog stagingu przygotowanego pakietu (bez zmian w systemie)."""
    if staged and staged.get("staging"):
        shutil.rmtree(staged["staging"], ignore_errors=True)


def _apply_staged_package(staged: dict, pkg: PackageInfo, deploy_dir: str = "",
                          backup_dir: str = "",
                          old_checksums: Optional[dict] = None
                          ) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
    """Faza commit: przenosi przygotowany pakiet do systemu.

    Hooki pre/post-install uruchamiane są tutaj – dopiero po tym, jak cała
    grupa pakietów została poprawnie rozpakowana w stagingu.
    """
    staging = staged["staging"]
    data_staging = staged["data"]
    sums = staged["sums"]
    hooks_dir = staged["hooks"]
    priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
    journal: List[tuple] = []
    installed_files: List[dict] = []
    backup_journal: List[Tuple[str, str]] = []

    try:
        # Hook pre-install (przed przeniesieniem plików do systemu)
        _run_hook(hooks_dir, "pre-install", pkg)

        # Przenieś pliki: staging/data/* → /
        for root, dirs, files in os.walk(data_staging):
            # Symlink do katalogu (np. /lib → usr/lib) os.walk zwraca w `dirs`.
            # Nie wolno tworzyć z niego prawdziwego katalogu – przekieruj do
            # pętli plików, gdzie _install_file odtworzy symlink.
            for _d in list(dirs):
                if os.path.islink(os.path.join(root, _d)):
                    dirs.remove(_d)
                    files.append(_d)

            # Odtwórz katalogi z pakietu – w tym PUSTE (np. /etc/pulse/default.pa.d).
            for d in dirs:
                src_dir = os.path.join(root, d)
                rel_dir = os.path.relpath(src_dir, data_staging)
                if deploy_dir and _is_shared_path("/" + rel_dir):
                    dst_root = PAG_ROOT
                elif deploy_dir:
                    dst_root = deploy_dir
                else:
                    dst_root = PAG_ROOT
                dst_dir = os.path.join(dst_root, rel_dir)
                if not os.path.isdir(dst_dir):
                    try:
                        os.makedirs(dst_dir, exist_ok=True)
                    except OSError:
                        pass
            for fname in files:
                if fname == "sums.json":
                    continue
                src = os.path.join(root, fname)
                rel = os.path.relpath(src, data_staging)

                ok = _install_file(src, rel, data_staging, sums,
                                   staging, journal, installed_files, deploy_dir,
                                   backup_dir, backup_journal,
                                   old_checksums=old_checksums,
                                   privileged=priv)
                if not ok:
                    # Cofnij wszystkie operacje
                    _rollback_journal(journal, staging)
                    return False, [], backup_journal

        # Odbuduj cache ikon GTK dla motywów dotkniętych instalacją.
        _icon_dirs = set()
        for f in installed_files:
            fp = f.get("path", "") or ""
            if fp.startswith("/usr/share/icons/"):
                _rest = fp[len("/usr/share/icons/"):]
                _theme = _rest.split("/", 1)[0]
                if _theme:
                    _icon_dirs.add(os.path.join(PAG_ROOT, "usr/share/icons", _theme))
        if _icon_dirs:
            try:
                subprocess.run(["gtk-update-icon-cache", "--version"],
                               capture_output=True, timeout=10)
                for _d in sorted(_icon_dirs):
                    if os.path.isdir(_d):
                        subprocess.run(["gtk-update-icon-cache", "-f", "-q", _d],
                                       capture_output=True, timeout=300)
            except Exception:
                pass

        # Uruchom hooki post-install
        _run_hook(hooks_dir, "post-install", pkg)

        # Zachowaj hooki na wypadek usunięcia pakietu (pre/post-remove)
        try:
            if os.path.isdir(hooks_dir):
                persisted = os.path.join(PAG_DB, "hooks", pkg.name)
                shutil.rmtree(persisted, ignore_errors=True)
                shutil.copytree(hooks_dir, persisted)
        except Exception:
            pass

        # Zapisz do SQLite
        _db_record_files(pkg.name, installed_files)

        shutil.rmtree(staging, ignore_errors=True)
        return True, installed_files, backup_journal

    except Exception as e:
        _rollback_journal(journal, staging)
        print(_('  ❌ {arg1}: commit error – {arg2}', arg1=(pkg.name), arg2=(e)))
        return False, [], backup_journal


def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
                    backup_dir: str = "",
                    old_checksums: Optional[dict] = None
                    ) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
    """Instaluje pojedynczy pakiet dwufazowo: staging → commit.

    Zachowane jako publiczny wrapper dla instalacji pojedynczych plików
    lokalnych; transakcja grupowa w cmd_install przygotowuje staging dla
    całej grupy i wywołuje _apply_staged_package bezpośrednio.
    """
    staged = _stage_package(pkg_path, pkg)
    if not staged:
        return False, [], []
    return _apply_staged_package(staged, pkg, deploy_dir, backup_dir, old_checksums)

def _refresh_dynamic_linker_cache(deploy_dir: str = "") -> bool:
    """Odświeża cache ld.so po udanej instalacji pakietów."""
    ldconfig = shutil.which("ldconfig")
    if not ldconfig:
        print(_('  ⚠ ldconfig not found — linker cache was not refreshed.'),
              file=sys.stderr)
        return False

    target_root = deploy_dir or PAG_ROOT
    command = [ldconfig]
    if target_root != "/":
        command.extend(["-r", target_root])

    try:
        subprocess.run(command, check=True, timeout=60,
                       stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
                       text=True)
        return True
    except (OSError, subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
        detail = getattr(exc, "stderr", None) or str(exc)
        print(_('  ⚠ Failed to refresh ld.so cache: {arg1}', arg1=(detail.strip())),
              file=sys.stderr)
        return False


def _rollback_journal(journal: list, staging_path: str):
    """Cofa wszystkie operacje z journala (odwrotna kolejność)."""
    for entry in reversed(journal):
        op = entry[0]
        if op == "file":
            _, src, dst = entry
            try:
                if os.path.exists(dst) or os.path.islink(dst):
                    _safe_rename(dst, src)
            except Exception:
                pass
        elif op == "symlink":
            _, _, dst = entry
            try:
                if os.path.islink(dst) or os.path.exists(dst):
                    os.remove(dst)
            except Exception:
                pass
        elif op == "backup":
            # Przywróć starą wersję pliku z backupu (upgrade)
            _, bpath, dst = entry
            try:
                if os.path.lexists(bpath):
                    os.replace(bpath, dst)
            except Exception:
                pass
    shutil.rmtree(staging_path, ignore_errors=True)

# =============================================================================
# BEZPIECZNE USUWANIE
# =============================================================================

def _safe_remove_files(pkg_name: str, installed_db: dict) -> Tuple[int, List[str]]:
    """
    Usuwa pliki pakietu, ale tylko jeśli NIE są współdzielone z innym pakietem.
    Zwraca (liczba usuniętych, [lista usuniętych ścieżek]).
    """
    pkg_files = _db_get_package_files(pkg_name)
    recorded = _db_get_package_checksums(pkg_name)
    removed = []
    skipped_shared = []
    skipped_sensitive = []

    for fpath in pkg_files:
        owners = _db_get_file_owners(fpath)
        # Sprawdź czy inny ZAINSTALOWANY pakiet też jest właścicielem
        other_owners = [o for o in owners if o != pkg_name and o in installed_db]

        if other_owners:
            # Plik współdzielony – tylko usuń wpis w DB, nie kasuj pliku
            skipped_shared.append(fpath)
            continue

        full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
        if os.path.isfile(full) or os.path.islink(full):
            # Wrażliwej konfiguracji systemowej (/etc/pam.d, sudoers, shadow…)
            # NIE kasujemy przy `remove` – jej brak potrafi zablokować logowanie
            # i sudo (np. usunięcie system-auth/system-account). Zostaje wpis w bazie.
            if _is_sensitive_config(fpath):
                skipped_sensitive.append(fpath)
                continue
            # .pacsave: zachowaj ZMIENIONY plik konfiguracyjny zamiast kasować
            # (porównanie z sumą z chwili instalacji), wzorzec jak w pacmanie.
            if not os.path.islink(full) and _is_config_path(fpath):
                old_sha = recorded.get(fpath, "")
                if old_sha:
                    try:
                        cur_sha = _sha256_file(full)
                    except OSError:
                        cur_sha = ""
                    if cur_sha and cur_sha != old_sha:
                        pacsave = full + ".pacsave"
                        try:
                            os.replace(full, pacsave)
                            print(f"      ⚠ {_('conf_pacsave', path=pacsave)}")
                            removed.append(fpath)
                            continue
                        except OSError:
                            pass
            os.remove(full)
            removed.append(fpath)

    # Usuń puste katalogi (od najgłębszych)
    dirs = set()
    for fpath in removed + skipped_shared:
        parent = os.path.dirname(fpath)
        while parent and parent != "/":
            dirs.add(parent)
            parent = os.path.dirname(parent)

    for d in sorted(dirs, key=len, reverse=True):
        full_d = os.path.join(PAG_ROOT, d.lstrip("/"))
        if os.path.isdir(full_d):
            try:
                os.rmdir(full_d)
            except OSError:
                pass  # nie jest pusty – OK

    # Usuń z SQLite
    _db_remove_package_files(pkg_name)

    if skipped_shared:
        print(_('      ⚠ {arg1} shared files preserved', arg1=(len(skipped_shared))))
    if skipped_sensitive:
        print(_('      ⚠ {arg1} sensitive system files preserved', arg1=(len(skipped_sensitive))))

    return len(removed) + len(skipped_shared) + len(skipped_sensitive), removed


def _remove_stale_files(pkg_name: str, old_files: List[str], new_paths: List[str],
                        installed_db: dict, deploy_dir: str = "",
                        backup_dir: str = "", backup_journal: Optional[list] = None) -> Tuple[int, List[str]]:
    """
    Po upgrade usuwa pliki starej wersji, których nie ma w nowej.

    - Pliki współdzielone z innym zainstalowanym pakietem są ZACHOWYWANE
      (usuwany jest tylko wpis z bazy `files` dla tego pakietu).
    - Sprząta puste katalogi i wpisy SQLite starej wersji.
    Zwraca (liczba usuniętych, [usunięte ścieżki]).
    """
    new_set = set(new_paths)
    # Warianty /usr/lib <-> /usr/lib64: plik obecny w nowej wersji pod równoważną
    # ścieżką NIE jest przestarzały. Bez tego upgrade kasował właśnie
    # zainstalowany plik, gdy stara i nowa wersja używały różnych libdir
    # (kolizja lib/lib64).
    new_effective = set()
    for _p in new_set:
        new_effective.add(_p)
        if _p.startswith("/usr/lib64/"):
            new_effective.add("/usr/lib/" + _p[len("/usr/lib64/"):])
        elif _p.startswith("/usr/lib/"):
            new_effective.add("/usr/lib64/" + _p[len("/usr/lib/"):])
    stale = [f for f in old_files if f not in new_effective]
    if not stale:
        return 0, []

    root = deploy_dir or PAG_ROOT
    removed = []
    skipped = 0
    for fpath in stale:
        owners = _db_get_file_owners(fpath)
        other_owners = [o for o in owners if o != pkg_name and o in installed_db]
        if other_owners:
            # Współdzielony z innym pakietem – tylko usuń wpis z DB dla tego pakietu
            skipped += 1
        else:
            # Wrażliwych plików systemowych NIE kasujemy, gdy nowy pakiet ich już
            # nie dostarcza (np. shadow przestaje pakować system-*). Ich brak
            # blokuje login/sudo; usuwamy więc tylko wpis w bazie.
            if _is_sensitive_config(fpath):
                skipped += 1
            else:
                # Gdy nowa wersja pliku /etc trafiła do .pacnew, plik użytkownika
                # MUSI zostać – nie jest „przestarzały”. Zachowujemy też wpis w bazie
                # (stara suma), by kolejny upgrade dalej wykrywał zmiany użytkownika.
                if _is_config_path(fpath):
                    _cfg_full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
                    if os.path.lexists(_cfg_full + ".pacnew"):
                        skipped += 1
                        continue
                full = os.path.join(root, fpath.lstrip("/"))
                if os.path.isfile(full) or os.path.islink(full):
                    try:
                        if backup_dir and backup_journal is not None:
                            backup_path = os.path.join(backup_dir, fpath.lstrip("/"))
                            os.makedirs(os.path.dirname(backup_path), exist_ok=True)
                            os.replace(full, backup_path)  # przenieś do backupu (rollback)
                            backup_journal.append((backup_path, fpath))
                        else:
                            os.remove(full)
                        removed.append(fpath)
                    except OSError:
                        pass
        # Usuń wpis `files` dla tego pakietu (stara wersja już go nie zawiera)
        with _db_session() as db:
            db.execute("DELETE FROM files WHERE package=? AND path=?", (pkg_name, fpath))

    # Usuń puste katalogi (od najgłębszych)
    dirs = set()
    for fpath in removed:
        parent = os.path.dirname(fpath)
        while parent and parent != "/":
            dirs.add(parent)
            parent = os.path.dirname(parent)
    for d in sorted(dirs, key=len, reverse=True):
        full_d = os.path.join(root, d.lstrip("/"))
        if os.path.isdir(full_d):
            try:
                os.rmdir(full_d)
            except OSError:
                pass  # nie jest pusty – OK

    if removed:
        print(_('  🧹 Removed {arg1} obsolete files ({arg2})', arg1=(len(removed)), arg2=(pkg_name)))
    if skipped:
        print(_('      ⚠ {arg1} shared files preserved', arg1=(skipped)))

    return len(removed), removed


def _new_transaction_backup_root() -> str:
    """Katalog na backupy NADPISYWANYCH plików dla bieżącej transakcji.

    Tworzony dla KAŻDEJ transakcji, nie tylko upgrade: „świeża” instalacja
    pakietu też potrafi nadpisać pliki spoza bazy pag (baza rootfs/ISO).
    Gdy transakcja padnie, rollback MUSI mieć co przywrócić – inaczej kasuje
    te pliki (tak zniknął m.in. libpam.so.0 i przestał działać sudo)."""
    txn = datetime.now().strftime("%Y%m%dT%H%M%S") + "-" + str(os.getpid())
    root = os.path.join(STAGING_DIR, "backups", txn)
    os.makedirs(root, exist_ok=True)
    return root


def _purge_old_backups(keep_root: str = ""):
    """Usuwa backupy starszych transakcji (zostawia bieżący – dla `pag rollback`)."""
    base = os.path.join(STAGING_DIR, "backups")
    if not os.path.isdir(base):
        return
    for entry in os.listdir(base):
        p = os.path.join(base, entry)
        if p != keep_root and os.path.isdir(p):
            shutil.rmtree(p, ignore_errors=True)


def _recover_interrupted_transactions(verbose=True) -> int:
    """Przywraca pliki po transakcji PRZERWANEJ w polowie (crash / kill -9).

    Backup transakcji (/.pag_staging/backups/<txn>) powstaje, ZANIM pliki zostana
    podmienione. Jesli pag zginie w trakcie, czesc plikow jest juz przeniesiona do
    backupu, a nowych jeszcze nie ma -> system zostaje bez pliku.

    Dla kazdego katalogu backupu, ktory NIE jest zapisany w historii jako UDANA
    transakcja (`upgrade_backup_root` przy `success=true`; takie zostawiamy dla
    `pag rollback`), przywracamy pliki nieobecne w systemie. Potem odswiezamy
    cache linkera.
    """
    base = os.path.join(STAGING_DIR, "backups")
    if not os.path.isdir(base):
        return 0
    try:
        history = load_json(HISTORY_FILE) or []
    except Exception:
        history = []
    done_roots = {
        e.get("upgrade_backup_root") for e in history
        if isinstance(e, dict) and e.get("success") and e.get("upgrade_backup_root")
    }
    restored = 0
    for txn in sorted(os.listdir(base)):
        root = os.path.join(base, txn)
        if not os.path.isdir(root) or root in done_roots:
            continue
        for dirpath, _dirs, files in os.walk(root):
            for fn in files:
                src = os.path.join(dirpath, fn)
                rel = os.path.relpath(src, root)
                dst = os.path.join(PAG_ROOT, rel)
                if os.path.lexists(dst):
                    continue
                try:
                    os.makedirs(os.path.dirname(dst), exist_ok=True)
                    if os.path.islink(src):
                        os.symlink(os.readlink(src), dst)
                    else:
                        shutil.copy2(src, dst)
                    restored += 1
                except OSError:
                    pass
    if restored:
        try:
            subprocess.run(["ldconfig"], capture_output=True, timeout=120)
        except Exception:
            pass
        if verbose:
            print(_('  🛠  Interrupted transaction detected – restored {arg1} missing files.', arg1=(restored)))
    return restored


# =============================================================================
# HOOKI
# =============================================================================
# Hooki uruchamiają dowolny plik z pakietu jako root — to naturalna cecha
# menedżera pakietów (apt/pacman też tak mają), dlatego MUSISZ ufać repozytorium.
# Aby ograniczyć ryzyko:
#   - hook dostaje minimalne, "czyste" środowisko (bez LD_PRELOAD, BASH_ENV itp.)
#   - hooki można wyłączyć (PAG_NO_HOOKS=1) i ustawić timeout (PAG_HOOK_TIMEOUT)
#   - każde uruchomienie jest logowane do /var/log/pag/audit.log
#   - hook ma wersjonowane API (PKG_HOOK_API)
# =============================================================================

# Lista wykonanych hooków — trafia do wpisu transakcji (informacja w rejestrze).
_HOOKS_RUN: List[str] = []


def _hook_env(pkg: PackageInfo, hook_name: str) -> dict:
    """Buduje minimalne środowisko dla hooka (bez niebezpiecznych zmiennych)."""
    return {
        "PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
        "HOME": "/root",
        "LANG": "C.UTF-8",
        "LC_ALL": "C.UTF-8",
        "PKG_NAME": pkg.name,
        "PKG_VERSION": pkg.version,
        "PKG_ACTION": hook_name,
        "PKG_HOOK_API": HOOK_API_VERSION,
    }


def _hook_timeout() -> int:
    """Timeout hooka w sekundach.

    Domyślnie 900 s, bo hooki jądra/NVIDIA budują moduły DKMS i initramfs –
    na wolniejszych maszynach to kilka minut. Krótszy limit (dawniej 60 s)
    zabijał hook w połowie i zostawiał /boot bez aktualnego initramfs.
    Nadpisz przez `PAG_HOOK_TIMEOUT`.
    """
    try:
        return max(1, int(os.environ.get("PAG_HOOK_TIMEOUT", "900")))
    except Exception:
        return 900


def _run_hook(hooks_dir: str, hook_name: str, pkg: PackageInfo) -> bool:
    """Uruchamia skrypt hooka jeśli istnieje.

    Zwraca True jeśli hook został WYKONANY (istniał i uruchomiono go), False w
    pozostałych przypadkach (brak pliku, wyłączone hooki, błąd). Obsługuje
    ograniczone środowisko, timeout, logowanie do audytu i rejestr w transakcji.
    """
    hook_path = os.path.join(hooks_dir, hook_name)
    if not os.path.exists(hook_path):
        return False

    if os.environ.get("PAG_NO_HOOKS", "") == "1":
        print(_('  ⚠ Hook skipped (PAG_NO_HOOKS=1): {arg1} for {arg2}', arg1=(hook_name), arg2=(pkg.name)))
        _audit(f"hook SKIP {hook_name} {pkg.name}-{pkg.version} (PAG_NO_HOOKS=1)")
        return False

    os.chmod(hook_path, 0o755)
    env = _hook_env(pkg, hook_name)
    tag = f"{hook_name} {pkg.name}-{pkg.version}"
    try:
        result = subprocess.run([hook_path], env=env, timeout=_hook_timeout(),
                                check=False, capture_output=True, text=True,
                                cwd="/")
        _HOOKS_RUN.append(tag)
        if result.returncode != 0:
            print(_('  ⚠ Hook {arg1} for {arg2} exited with code {arg3}', arg1=(hook_name), arg2=(pkg.name), arg3=(result.returncode)))
            if result.stderr:
                print(f"      {result.stderr.strip()[-200:]}")
            _audit(f"hook FAIL {tag} rc={result.returncode}")
        else:
            _audit(f"hook OK {tag}")
        return True
    except subprocess.TimeoutExpired:
        print(_('  ⚠ Hook {arg1} for {arg2} timed out ({arg3}s)', arg1=(hook_name), arg2=(pkg.name), arg3=(_hook_timeout())))
        print(_('     Increase PAG_HOOK_TIMEOUT (e.g. PAG_HOOK_TIMEOUT=1800) and retry.'))
        _audit(f"hook TIMEOUT {tag}")
        return False
    except Exception as e:
        print(_('  ⚠ Hook {arg1} for {arg2}: {arg3}', arg1=(hook_name), arg2=(pkg.name), arg3=(e)))
        _audit(f"hook ERROR {tag}: {e}")
        return False

# =============================================================================
# TRANSAKCJE I ROLLBACK
# =============================================================================

def _record_transaction(action, packages, success, snapshot, file_journal=None, hooks=None,
                        upgrade_backups=None, upgrade_backup_root="", snapshot_id=""):
    history = load_json(HISTORY_FILE) if os.path.exists(HISTORY_FILE) else []
    # Rejestr wykonanych hooków – informacja o tym, że uruchomiono kod pakietu
    # jako root. Trafia do historii, by dało się później sprawdzić, co się działo.
    executed_hooks = list(_HOOKS_RUN) if hooks is None else hooks
    _HOOKS_RUN.clear()
    entry = {
        "action": action, "packages": packages, "success": success,
        "timestamp": datetime.now().isoformat(),
        "snapshot": snapshot,
        "file_journal": file_journal,  # lista plików do wycofania
        "hooks": executed_hooks,       # wykonane hooki (pre/post-install/remove)
    }
    if snapshot_id:
        # Snapshot systemu (btrfs) z chwili PRZED transakcją – można z niego
        # uruchomić system z menu GRUB albo podejrzeć `pag snapshot-list`.
        entry["snapshot_id"] = snapshot_id
    if upgrade_backups:
        entry["upgrade_backups"] = upgrade_backups     # {dst: backup_path}
        entry["upgrade_backup_root"] = upgrade_backup_root
    history.append(entry)
    if len(history) > 50:
        history = history[-50:]
    save_json(HISTORY_FILE, history)

def _action_label(action):
    key = "action_" + str(action)
    return _(key) if key in T.get("en", {}) else str(action)

def cmd_history():
    if not os.path.exists(HISTORY_FILE):
        print(_("no_history")); return
    history = load_json(HISTORY_FILE)
    if not history:
        print(_("no_history")); return
    print(_('Recent transactions ({arg1}):', arg1=(len(history))))
    for i, e in enumerate(reversed(history), 1):
        icon = "✅" if e["success"] else "❌"
        pkgs = ", ".join(e["packages"][:5])
        if len(e["packages"]) > 5: pkgs += f" (+{len(e['packages'])-5})"
        print(f"  {i}. {icon} {_action_label(e['action'])}: {pkgs}")
        print(f"     {e['timestamp']}")

def cmd_rollback():
    if not os.path.exists(HISTORY_FILE):
        print(_("no_history")); return 1
    history = load_json(HISTORY_FILE)
    if not history:
        print(_("no_history")); return 1

    last = None
    for e in reversed(history):
        if e["success"] and e.get("snapshot"):
            last = e; break

    if not last:
        print(_('❌ No snapshot to restore.')); return 1

    print(_('⏪ Rolling back: {arg1} ({arg2})', arg1=(_action_label(last['action'])), arg2=(last['timestamp'])))
    print(_('   Packages: {arg1}', arg1=(', '.join(last['packages'][:10]))))

    if not _ask_confirm():
        return 0

    # Przywróć installed.json
    save_json(INSTALLED_DB, last["snapshot"])

    # Wycofaj fizyczne pliki (jeśli zapisano journal)
    # Deduplikacja: pakiet może zgłosić ten sam plik więcej niż raz (np. przez
    # `provides` lub wspólną ścieżkę), a journal z historii mógł zostać zapisany
    # przed dodaniem deduplikacji.
    file_journal = list(dict.fromkeys(last.get("file_journal", [])))
    upgrade_backups = last.get("upgrade_backups", {}) or {}
    backup_root = last.get("upgrade_backup_root", "")

    # Przywróć stare wersje z backupów (upgrade) – nadpisane i usunięte stale pliki
    for dst, bpath in upgrade_backups.items():
        full = os.path.join(PAG_ROOT, dst.lstrip("/"))
        if bpath and os.path.lexists(bpath):
            try:
                os.makedirs(os.path.dirname(full), exist_ok=True)
                os.replace(bpath, full)
            except OSError:
                pass

    # Usuń nowe pliki (które nie miały poprzedniej wersji)
    backed = set(upgrade_backups)
    if file_journal:
        for fpath in reversed(file_journal):
            if fpath in backed:
                continue
            full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
            if os.path.exists(full) or os.path.islink(full):
                os.remove(full)
        print(f"   {_('rollback_files', len(file_journal))}")

    # Sprzątanie pustych katalogów + katalogu backupów
    dirs = set()
    for fpath in file_journal:
        parent = os.path.dirname(fpath)
        while parent and parent != "/":
            dirs.add(parent)
            parent = os.path.dirname(parent)
    for d in sorted(dirs, key=len, reverse=True):
        full_d = os.path.join(PAG_ROOT, d.lstrip("/"))
        if os.path.isdir(full_d):
            try:
                os.rmdir(full_d)
            except OSError:
                pass
    if backup_root:
        shutil.rmtree(backup_root, ignore_errors=True)

    print(f"✅ {_('rollback_restored')}")
    _record_transaction("rollback", last["packages"], True, None)
    return 0

# =============================================================================
# INSTALACJA
# =============================================================================

def _install_local_pkg_files(paths, install_succeeded):
    """Instaluje lokalne pliki .pag (bez repozytorium).

    Najpierw przygotowuje WSZYSTKIE paczki w stagingu, potem je nakłada.
    Dzięki temu uszkodzony plik w środku grupy nie zostawia systemu
    w połowie instalacji. Zwraca (failed_count, installed_files).
    """
    failed = 0
    prepared = []
    for p in paths:
        p = os.path.abspath(p)
        if not os.path.isfile(p):
            print(_('  ❌ Package not found: {arg1}', arg1=(p)))
            failed += 1
            break
        if not _verify_local_pkg_signature(p):
            failed += 1
            break
        try:
            with tarfile.open(p, "r:xz") as tf:
                meta = tf.extractfile("metadata.json")
                if meta is None:
                    print(_('  ❌ {arg1}: missing metadata.json', arg1=(p)))
                    failed += 1
                    break
                data = json.loads(meta.read())
        except Exception as e:
            print(_('  ❌ {arg1}: failed to read package ({arg2})', arg1=(p), arg2=(e)))
            failed += 1
            break
        pkg = PackageInfo(data, repo="local")
        staged = _stage_package(p, pkg)
        if not staged:
            failed += 1
            break
        prepared.append((pkg, staged))

    if failed:
        for _pkg, _st in prepared:
            _discard_staged(_st)
        print(_('  ↩ Preparation stage failed – the system was NOT changed.'))
        return failed, []

    all_files = []
    for pkg, staged in prepared:
        print(_('  ↓ {arg1}-{arg2} (local) ... ', arg1=(pkg.name), arg2=(pkg.version)), end="", flush=True)
        ok, files, _ = _apply_staged_package(staged, pkg)
        if ok:
            install_succeeded(pkg, files)
            all_files.extend(f["path"] for f in files)
            print("✅")
        else:
            print("❌")
            failed += 1
    return failed, all_files


def _preflight_disk(total_bytes: int) -> bool:
    """Pre-flight przed transakcją: wolne miejsce + mount read-only.

    Zwraca False (przerywa instalację) gdy na partycji docelowej brakuje
    miejsca na pakiety albo katalog stagingu jest zamontowany read-only
    (inaczej instalacja rwałaby się w połowie, zostawiając uszkodzony system).
    """
    target = PAG_ROOT or "/"
    try:
        st = os.statvfs(target)
        free = st.f_bavail * st.f_frsize
    except OSError:
        return True  # nie da się sprawdzić – nie blokuj
    need_mb = total_bytes // 1048576
    free_mb = free // 1048576
    if free < total_bytes:
        print(_('  ❌ Not enough disk space: need ~{arg1} MB, free {arg2} MB ({arg3})', arg1=(need_mb), arg2=(free_mb), arg3=(target)))
        return False
    if free < total_bytes * 3:
        print(_('  ⚠ Low disk space: {arg1} MB free, packages ~{arg2} MB (extracted will take more)', arg1=(free_mb), arg2=(need_mb)))
    # Wykryj mount read-only (test zapisu w stagingu)
    try:
        probe = os.path.join(STAGING_DIR, ".pag-probe")
        with open(probe, "w") as f:
            f.write("x")
        os.remove(probe)
    except OSError:
        print(_('  ❌ {arg1} is mounted read-only – cannot install.', arg1=(target)))
        return False
    return True


def cmd_install(package_names, as_dep=False, upgrade=False):
    ensure_dirs()
    installed_db = load_json(INSTALLED_DB)
    world = load_world()
    pinned = load_json(PINNED_FILE)

    # Obsługa lokalnych plików .pkg.tar.xz (zbudowanych przez pagbuild) –
    # nie wymaga repozytorium ani GPG.
    local_files = [p for p in package_names if p.endswith(PKG_EXT) or
                   (os.sep in p and os.path.isfile(os.path.abspath(p)))]
    if local_files:
        _local_need = sum(
            os.path.getsize(os.path.abspath(p))
            for p in local_files if os.path.isfile(os.path.abspath(p))
        )
        if not _preflight_disk(_local_need):
            return 1

        def _ok(pkg, files):
            installed_db[pkg.name] = {
                "version": pkg.version, "release": pkg.release, "description": pkg.description,
                "dependencies": pkg.dependencies, "size_bytes": pkg.size_bytes,
                "sha256": pkg.sha256, "installed_at": datetime.now().isoformat(),
                "repo": "local",
                "provides": getattr(pkg, "provides", None) or [],
                "provides_so": getattr(pkg, "provides_so", None) or [],
                "requires_so": getattr(pkg, "requires_so", None) or [],
            }
            world.add(pkg.name)
        failed_local, _fl = _install_local_pkg_files(local_files, _ok)
        save_json(INSTALLED_DB, installed_db)
        save_world(world)
        if failed_local:
            return 1
        _refresh_dynamic_linker_cache()
        package_names = [n for n in package_names if n not in
                         [os.path.abspath(x) for x in local_files] and
                         n not in local_files]
        to_install = []
        if not package_names:
            return 0
        # pozostałe argumenty to nazwy pakietów z repo – kontynuuj

    repo_pkgs = fetch_all_packages()

    if not repo_pkgs:
        print(f"❌ {_('no_index')}"); return 1

    for name in list(package_names):
        if name in pinned:
            print(f"⚠ {name} {_('pinned_to')} {pinned[name]} – skipping")
            package_names.remove(name)

    to_install, missing_deps = _resolve_deps(package_names, repo_pkgs, installed_db)

    # ── Pakiety, których NIE MA w repo ani nie są zainstalowane ──
    # Zgłoś od razu zamiast mylącego „Do zainstalowania: N (0.00 MB)”
    # i prośby o potwierdzenie (np. `pag install steam` gdy steam nie istnieje).
    not_found = []
    for n in package_names:
        real = _resolve_provides(n, repo_pkgs, installed_db)
        if real not in repo_pkgs and real not in installed_db \
           and not os.path.exists(os.path.abspath(n)):
            not_found.append(n)
    if not_found:
        print(f"\n  ❌ {_('pkg_not_found', ', '.join(not_found))}")
        print(f"     {_('not_found_hint')}")
        return 1

    # --- Tryb upgrade: pakiety już zainstalowane MUSZĄ zostać ponownie
    # zainstalowane z nowszej wersji (zastąpienie w tej samej transakcji).
    if upgrade:
        # `pag update` przekazuje tu tylko pakiety z NOWSZĄ wersją (już
        # przefiltrowane w _pending_updates), a `pag install -f` wymusza
        # reinstalację nawet tej SAMEJ wersji – dlatego nie filtrujemy po
        # _version_newer.
        upgrade_targets = [
            name for name in package_names
            if name in repo_pkgs
            and name in installed_db
            and name not in pinned
        ]
        for name in upgrade_targets:
            if name not in to_install:
                to_install.append(name)

    if not to_install and not missing_deps:
        print(f"✅ {_('all_installed')}"); return 0

    # ── WERYFIKACJA ZALEŻNOŚCI ──────────────────────────────────────────
    fatal_missing = _verify_dependencies(to_install, repo_pkgs, installed_db)

    if fatal_missing > 0:
        print(_('❌ Cannot continue – {arg1} missing dependencies.', arg1=(fatal_missing)))
        print(_('   Install the missing packages or add repositories.'))
        return 1

    so_missing = _verify_so_deps(to_install, repo_pkgs, installed_db)
    if so_missing > 0:
        print(_('   Install the library provider or update the repository.'))
        return 1

    if not to_install:
        print(f"✅ {_('all_installed')}"); return 0

    MAX_MB = MAX_PKG_SIZE // 1048576
    for n in to_install:
        if not _validate_pkg_name(n):
            print(f"  {_("sec_badname", name=n)}")
            return 1
        sz = repo_pkgs[n].size_bytes if n in repo_pkgs else 0
        if sz > MAX_PKG_SIZE:
            mb = sz // 1048576
            print(f"  {_("sec_toobig", size_mb=mb, max_mb=MAX_MB)}")
            return 1
    total_size = sum(repo_pkgs[n].size_bytes for n in to_install if n in repo_pkgs)
    if not _preflight_disk(total_size):
        return 1
    print(f"\n📦 {_('to_install', len(to_install), total_size/1048576)}")
    for name in to_install:
        p = repo_pkgs.get(name)
        if p:
            if name in installed_db:
                marker = f" {_('upgrade_marker')}" if upgrade else ""
            else:
                marker = f" [{_('new')}]"
            print(f"   {name}-{p.version}{marker}")

    # Pakiet z bazy obrazu ISO (nie w installed.json) → ostrzeż, że pliki z ISO
    # zostaną zastąpione pakietem z repo (kopia do `pag rollback`).
    _base_warn_overwrite(to_install)

    if not as_dep and not upgrade:
        if not _ask_confirm():
            print(_("cancelled")); return 0

    # `--dry-run`: pokaż plan i wyjdź. Nic nie jest pobierane, rozpakowywane
    # ani zmieniane – bezpieczne sprawdzenie, co zrobiłaby transakcja.
    if os.environ.get("PAG_DRY_RUN", "") == "1":
        print(f"\n  🧪 {_('dry_run_plan')}")
        for _n in to_install:
            _p = repo_pkgs.get(_n)
            if _p:
                _mark = f" {_('upgrade_marker')}" if _n in installed_db else f" [{_('new')}]"
                print(f"    {_n}-{_p.version}{_mark}")
        print(f"  {_('dry_run_done')}")
        return 0

    snapshot = copy.deepcopy(installed_db)
    all_installed_files = []
    failed = []
    # Pary (pkg, stare_pliki, nowe_pliki) do usunięcia martwych plików po upgrade
    stale_candidates = []
    # Katalog backupów nadpisywanych plików – dla poprawnego rollbacku.
    # Dla KAŻDEJ transakcji: instalacja „nowego” pakietu także nadpisuje pliki
    # spoza bazy pag (baza rootfs/ISO), a rollback bez backupu by je skasował.
    backup_root = ""
    all_backups: List[Tuple[str, str]] = []  # (backup_path, dst)
    if to_install:
        backup_root = _new_transaction_backup_root()

    # --- Dziennik transakcji (dla pełnej atomowości) ---
    # Jeśli którykolwiek pakiet zawiedzie, cofamy WSZYSTKIE zainstalowane
    # w tej transakcji przez _rollback_transaction().
    transaction_journal: List[Tuple[str, str, str]] = []  # (op, src, dst)

    # --- Tryb immutable: utwórz nowy deployment ---
    immutable = os.environ.get("PAG_IMMUTABLE", "") == "1"
    deploy_dir = ""
    deploy_id = ""
    if immutable:
        print(_('\n  🏗️  Creating a new deployment...'))
        deploy_dir, deploy_id = _create_deployment(to_install, "upgrade" if upgrade else "install")
        target_root = deploy_dir
    else:
        target_root = ""

    # --- Faza 1: Równoległe pobieranie wszystkich pakietów ---
    to_download = [repo_pkgs[name] for name in to_install if name in repo_pkgs]
    if len(to_download) > 1:
        print(_('\n  ⏬ Downloading {arg1} packages in parallel...', arg1=(len(to_download))))
        downloaded = _download_packages_parallel(to_download)
    else:
        downloaded = {}

    # --- Faza 1b: WERYFIKACJA WSZYSTKICH paczek PRZED instalacją ---
    # KLUCZOWE: GPG i SHA256 sprawdzamy dla WSZYSTKICH paczek, ZANIM
    # zainstalujemy choćby jedną. Inaczej instalowany pakiet może podmienić
    # bibliotekę używaną przez sam gpg (np. libassuan 3.0.1 zmienił namespace
    # symboli LIBASSUAN_1.0 -> LIBASSUAN_2.0) i wtedy weryfikacja kolejnych
    # paczek w tej samej transakcji pada, dając fałszywe
    # „NIEPRAWIDŁOWY PODPIS GPG".
    verified = {}
    _vfail = []
    for _name in to_install:
        _pkg = repo_pkgs.get(_name)
        if not _pkg:
            _vfail.append((_name, _('not_found')))
            continue
        _pp = downloaded.get(_name)
        if not _pp:
            _pp = _download_pkg(_pkg)
        if not _pp:
            _vfail.append((_name, _('download_fail')))
            continue
        _gok, _gmsg = _verify_pkg_gpg(_pp, repo_url=_pkg.repo_url)
        if not _gok:
            _vfail.append((_name, f"{_('gpg_fail')}: {_gmsg[:60]}"))
            continue
        if _pkg.sha256 and _sha256_file(_pp) != _pkg.sha256:
            _vfail.append((_name, _('sha256_mismatch')))
            continue
        verified[_name] = _pp
    if _vfail:
        for _n, _m in _vfail:
            print(f"  ❌ {_n}: {_m}")
        print(_('  ↩ Aborted BEFORE installation – no package was changed.'))
        return 1

    # --- Snapshot systemu PRZED transakcją (btrfs CoW) ---
    # Tworzymy go PO pobraniu i weryfikacji paczek, ale PRZED rozpakowaniem
    # czegokolwiek do systemu. Domyślnie `auto`: tylko na btrfs. `--snapshot`
    # wymusza migawkę (i przerywa, gdy się nie uda), `--no-snapshot` wyłącza.
    snapshot_mode = (os.environ.get("PAG_SNAPSHOT") or "auto").strip().lower()
    sys_snap: Optional[dict] = None
    if to_install and snapshot_mode not in ("never", "no", "0", "off"):
        _snap_ok, _snap_why = _snapshot_support()
        if _snap_ok:
            sys_snap = _create_system_snapshot(
                to_install, "upgrade" if upgrade else "install")
            if sys_snap:
                _refresh_bootloader()
            elif snapshot_mode in ("always", "require", "1", "yes"):
                print(_('  ❌ Failed to create snapshot (--snapshot mode) – aborting.'))
                return 1
        elif snapshot_mode in ("always", "require", "1", "yes"):
            print(f"  ❌ {_('snapshot_unsupported', _snap_why)}")
            return 1
        else:
            print(f"  ℹ {_('snapshot_unsupported', _snap_why)}")

    # --- Faza 1c: PRZYGOTOWANIE CAŁEJ GRUPY W STAGINGU ---
    # Rozpakowujemy WSZYSTKIE pakiety do `/.pag_staging/.stage-*`, zanim
    # dotkniemy systemu. Jeśli jedna z 50 paczek (np. GNOME) jest uszkodzona,
    # transakcja kończy się tutaj – na dysku nie ma żadnych zmian.
    atomic = os.environ.get("PAG_ATOMIC", "1") != "0"
    staged_pkgs: List[Tuple[str, PackageInfo, Optional[dict]]] = []
    if atomic and to_install:
        print(f"\n  🧰 {_('staging_prepare', len(to_install))}")
        _sbar = _StepBar(len(to_install), icon="🧰 ", width=25)
        _stage_failed: List[str] = []
        for _si, _name in enumerate(to_install, 1):
            _pkg = repo_pkgs.get(_name)
            _pp = verified.get(_name)
            if not _pkg or not _pp:
                _stage_failed.append(_name)
                break
            _sbar.step(_si, f"{_name}-{_pkg.version}")
            _st = _stage_package(_pp, _pkg)
            if not _st:
                _stage_failed.append(_name)
                break
            staged_pkgs.append((_name, _pkg, _st))
        _sbar.end()
        if _stage_failed:
            for _n, _p, _st in staged_pkgs:
                _discard_staged(_st)
            print(f"  ↩ {_('staging_failed')}")
            if backup_root:
                shutil.rmtree(backup_root, ignore_errors=True)
            _record_transaction("upgrade" if upgrade else "install", to_install, False,
                                snapshot,
                                snapshot_id=sys_snap["id"] if sys_snap else "")
            return 1
        print(f"  ✅ {_('staging_commit')}")
    elif to_install:
        staged_pkgs = [(n, repo_pkgs[n], None) for n in to_install]

    # --- Faza 2: Instalacja – JEDNA nadpisywana linia postępu (jak przy
    # pobieraniu), bez ściany tekstu na każdy pakiet. W trybie
    # nieinteraktywnym (logi, netinstall instalatora) wypisujemy linię na
    # pakiet – tam to pożądane do logu.
    t0 = time.time()
    stdout_tty = sys.stdout.isatty()

    # Animowany pasek postępu („drakkar”) – jedna nadpisywana linia; morze
    # faluje nawet wtedy, gdy pojedynczy pakiet instaluje się długo.
    _pbar = _StepBar(len(to_install), icon="📦 ", width=25)

    def _bar_draw(idx: int, name: str) -> None:
        _pbar.step(idx, name)

    def _bar_end() -> None:
        _pbar.end()

    for _pkg_i, (name, pkg, _staged) in enumerate(staged_pkgs, 1):
        if not pkg:
            _bar_end()
            print(f"  ❌ {name}: {_('not_found')}")
            failed.append(name)
            break

        _bar_draw(_pkg_i, f"{name}-{pkg.version}")

        # Przed instalacją zapamiętaj pliki starej wersji (potrzebne w upgrade)
        old_files = _db_get_package_files(name) if name in installed_db else []
        # Stare sumy SHA256 – do wykrycia zmian użytkownika w plikach /etc (.pacnew)
        old_checksums = _db_get_package_checksums(name) if name in installed_db else None

        # Commit przygotowanego pakietu (w upgrade backupuje nadpisywane pliki).
        # Tryb `PAG_ATOMIC=0` zachowuje starą ścieżkę pojedynczą (staging per pakiet).
        if _staged is not None:
            ok, files, backup_j = _apply_staged_package(
                _staged, pkg, deploy_dir,
                backup_dir=backup_root,
                old_checksums=old_checksums)
        else:
            # Ścieżka pobrana i ZWERYFIKOWANA w fazie 1b.
            pkg_path = verified.get(name)
            if not pkg_path:
                _bar_end()
                print(f"  ❌ {name}: {_('download_fail')}")
                failed.append(name)
                break  # przerwij transakcję
            ok, files, backup_j = _atomic_install(
                pkg_path, pkg, deploy_dir,
                backup_dir=backup_root,
                old_checksums=old_checksums)
        if ok:
            installed_db[name] = {
                "version": pkg.version, "release": pkg.release, "description": pkg.description,
                "dependencies": pkg.dependencies, "size_bytes": pkg.size_bytes,
                "sha256": pkg.sha256, "installed_at": datetime.now().isoformat(),
                "repo": pkg.repo_url,
                "provides": getattr(pkg, "provides", None) or [],
                "provides_so": getattr(pkg, "provides_so", None) or [],
                "requires_so": getattr(pkg, "requires_so", None) or [],
            }
            if not as_dep and name in package_names:
                world.add(name)
            if not stdout_tty:
                print(f"  ✓ {name}-{pkg.version}", flush=True)
            all_installed_files.extend(f["path"] for f in files)
            all_backups.extend(backup_j)

            # Upgrade: zapamiętaj stare pliki, by po sukcesie usunąć te,
            # których nie ma już w nowej wersji.
            if upgrade and old_files:
                stale_candidates.append((name, old_files, [f["path"] for f in files]))
        else:
            _bar_end()
            print(f"  ❌ {name}: {_('install_failed')}")
            failed.append(name)
            break  # PRZERWIJ – błąd instalacji

    # Deduplikacja journalu – ten sam plik może trafić tu dwukrotnie (np. przez
    # `provides`); rollback i historia nie potrzebują duplikatów.
    all_installed_files = list(dict.fromkeys(all_installed_files))

    # --- Rollback całej transakcji jeśli cokolwiek zawiodło ---
    if failed:
        _bar_end()
        print(_('\n  ↩ Rolling back transaction ({arg1} errors)...', arg1=(len(failed))))
        for _n, _p, _st in staged_pkgs:
            _discard_staged(_st)
        _rollback_transaction(installed_db, snapshot, all_installed_files,
                              deploy_dir, immutable, backups=all_backups)
        if backup_root:
            shutil.rmtree(backup_root, ignore_errors=True)
        _record_transaction("upgrade" if upgrade else "install", to_install, False,
                            snapshot,
                            snapshot_id=sys_snap["id"] if sys_snap else "")
        return 1

    save_json(INSTALLED_DB, installed_db)
    save_world(world)

    # --- Po ZAPISANIU bazy: usuń nieaktualne pliki starych wersji (upgrade).
    # Kolejność ma znaczenie: najpierw utrwalamy stan nowej wersji w bazie, a
    # dopiero potem kasujemy pliki, których nowa wersja nie zawiera. Odwrotna
    # kolejność (kasowanie przed zapisem) przy przerwaniu zostawiała system bez
    # plików. Usunięte pliki trafiają do backupu, aby `pag rollback` mógł je
    # przywrócić.
    for pkg_name, old_files, new_paths in stale_candidates:
        _remove_stale_files(pkg_name, old_files, new_paths, installed_db, deploy_dir,
                            backup_root, all_backups)
    _record_transaction("upgrade" if upgrade else "install", to_install, True, snapshot,
                         file_journal=all_installed_files,
                         upgrade_backups={dst: bp for bp, dst in all_backups} if all_backups else None,
                         upgrade_backup_root=backup_root,
                         snapshot_id=sys_snap["id"] if sys_snap else "")

    # Zachowaj backupy bieżącej transakcji (dla `pag rollback`), usuń starsze.
    if backup_root:
        _purge_old_backups(keep_root=backup_root)

    _bar_end()

    # --- Tryb immutable: przełącz na nowy deployment ---
    if immutable and not failed:
        _refresh_dynamic_linker_cache(deploy_dir)
        # Initramfs dla deploymentu budujemy RAZ – po wszystkich pakietach,
        # żeby zawierał też moduły nvidia/vbox dołożone w tej transakcji.
        if any(_needs_initramfs_refresh(_n) for _n in to_install):
            print(_('\n  🐧 Finalizing kernel/driver update in deployment (depmod + initramfs)...'))
            _refresh_depmod(deploy_dir)
            _rebuild_initramfs(deploy_dir)
        print(_('\n  🔄 Switching to deployment {arg1}...', arg1=(deploy_id)))
        _switch_deployment(deploy_dir)
        print(_('  ✅ Active deployment: {arg1}', arg1=(deploy_id)))
        _update_grub_config()
        cmd_deploy_cleanup(keep=5)  # Zostawia 5 najnowszych deploymentów
        print(_('  💡 Restart required to reload the system.'))
    else:
        _refresh_dynamic_linker_cache()
        # Hooki zbiorcze – raz na transakcję (fc-cache itp.), tylko gdy pliki
        # trafiły do realnego systemu (nie do deploymentu).
        _process_triggers(all_installed_files)
        # Jądro/sterowniki zmienione na ZWYKŁEJ instalacji → DKMS + initramfs +
        # GRUB, dokładnie RAZ i po wszystkich pakietach. Hook pakietu nie może
        # odświeżyć GRUB-a (trzymany lock PAG-a), a wcześniejsza przebudowa
        # initramfs w pętli dawała fałszywe ETA i dublowała pracę.
        if any(_needs_initramfs_refresh(_n) for _n in to_install):
            print(_('\n  🐧 Finalizing kernel/driver update (DKMS → depmod → initramfs → GRUB)...'))
            _post_kernel_hooks()
        elif sys_snap:
            # Snapshot istnieje, ale nie było zmiany jądra – odśwież menu GRUB,
            # żeby wpis migawki był widoczny przy najbliższym starcie.
            _ensure_snapshot_grub_script()
            _refresh_bootloader()

    print(f"\n✅ {_('installed', len(to_install))} ({(time.time()-t0):.0f}s)")
    return 0


def _rollback_transaction(installed_db: dict, snapshot: dict,
                           installed_files: List[str],
                           deploy_dir: str, is_immutable: bool,
                           backups: Optional[List[Tuple[str, str]]] = None):
    """
    Cofa WSZYSTKIE pakiety zainstalowane w bieżącej transakcji.
    Przywraca installed_db do stanu sprzed transakcji.
    Usuwa fizyczne pliki z systemu (lub deploymentu w trybie immutable).
    Jeśli podano `backups` (upgrade) – przywraca stare wersje nadpisanych plików.
    """
    # Przywróć installed_db
    installed_db.clear()
    installed_db.update(snapshot)

    root = deploy_dir if is_immutable else PAG_ROOT
    backup_map = {dst: src for src, dst in (backups or [])}

    # Przywróć stare wersje z backupów (upgrade)
    for dst, bpath in backup_map.items():
        full = os.path.join(root, dst.lstrip("/"))
        if os.path.lexists(bpath):
            try:
                os.makedirs(os.path.dirname(full), exist_ok=True)
                os.replace(bpath, full)
            except OSError:
                pass

    # Usuń nowe pliki (które nie miały poprzedniej wersji)
    for fpath in reversed(installed_files):
        if fpath in backup_map:
            continue
        full = os.path.join(root, fpath.lstrip("/"))
        if os.path.isfile(full) or os.path.islink(full):
            try:
                os.remove(full)
            except OSError:
                pass

    # Wyczyść puste katalogi
    dirs_to_check = set()
    for fpath in installed_files:
        parent = os.path.dirname(fpath)
        while parent and parent != "/":
            dirs_to_check.add(parent)
            parent = os.path.dirname(parent)
    for d in sorted(dirs_to_check, key=len, reverse=True):
        full_d = os.path.join(root, d.lstrip("/"))
        if os.path.isdir(full_d):
            try:
                os.rmdir(full_d)
            except OSError:
                pass

    # W trybie immutable: usuń nieudany deployment
    if is_immutable and deploy_dir:
        shutil.rmtree(deploy_dir, ignore_errors=True)

    save_json(INSTALLED_DB, snapshot)


# =============================================================================
# USUWANIE
# =============================================================================

def cmd_remove(package_names):
    installed_db = load_json(INSTALLED_DB)
    world = load_world()
    snapshot = copy.deepcopy(installed_db)
    removed = []
    removed_files = []

    total = len(package_names)
    for i, name in enumerate(package_names, 1):
        if name not in installed_db:
            print(_('  ⚠ {arg1}: not installed', arg1=(name))); continue

        # Pasek postępu (animowany „drakkar” na TTY)
        pct = (i - 1) / total * 100
        bar = _pagan_bar(pct, 25, time.time(), animated=sys.stderr.isatty())
        print(f"  🗑 [{bar}] {i}/{total} ({pct:.0f}%)  ", end="\r", file=sys.stderr, flush=True)

        print(f"🗑 {name}-{installed_db[name]['version']} ...", end=" ", flush=True)

        # Pre-remove hook (jeśli dostępny w staging)
        _run_hook_for_installed(name, "pre-remove")

        count, rm_files = _safe_remove_files(name, installed_db)
        del installed_db[name]
        world.discard(name)
        removed.append(name)
        removed_files.extend(rm_files)
        print(_('✅ ({arg1} files)', arg1=(count)))

        # Post-remove hook + sprzątanie zapisanych hooków
        _run_hook_for_installed(name, "post-remove")
        shutil.rmtree(os.path.join(PAG_DB, "hooks", name), ignore_errors=True)

    save_json(INSTALLED_DB, installed_db)
    save_world(world)
    _record_transaction("remove", removed, True, snapshot)

    print(file=sys.stderr)  # wyczyść linię paska postępu

    if not removed: return 0
    print(_('\n✅ Removed {arg1}.', arg1=(len(removed))))
    _process_triggers(removed_files)

    orphans = _find_orphans(installed_db, world)
    if orphans:
        print(f"\n💡 {_('orphans_found', len(orphans), ', '.join(sorted(orphans)[:10]))}")
        print(_("   'pag remove-orphans' to clean up."))
    return 0

def _run_hook_for_installed(pkg_name, hook_name):
    """Próbuje uruchomić hook z katalogu pakietu (jeśli został zapisany)."""
    hook_dir = os.path.join(PAG_DB, "hooks", pkg_name)
    if os.path.isdir(hook_dir):
        ver = load_json(INSTALLED_DB).get(pkg_name, {}).get("version", "")
        _run_hook(hook_dir, hook_name, PackageInfo({"name": pkg_name, "version": ver}))


# =============================================================================
# TRIGGERS – hooki zbiorcze (raz na transakcję, nie per pakiet)
# =============================================================================
# Wzorem pacman/dpkg: pakiet/administrator deklaruje zainteresowanie ścieżkami,
# a pasujący trigger uruchamia się DOKŁADNIE RAZ na końcu transakcji
# (np. fc-cache, glib-compile-schemas, update-desktop-database) zamiast po
# każdym pakiecie z osobna.

TRIGGERS_DIR = PAG_CONF + "/triggers"

DEFAULT_TRIGGERS = [
    {"name": "font-cache", "paths": ["/usr/share/fonts/", "/usr/local/share/fonts/"],
     "run": "fc-cache -fs"},
    {"name": "glib-schemas", "paths": ["/usr/share/glib-2.0/schemas/"],
     "run": "glib-compile-schemas /usr/share/glib-2.0/schemas"},
    {"name": "desktop-database", "paths": ["/usr/share/applications/"],
     "run": "update-desktop-database -q /usr/share/applications"},
    {"name": "mime-database", "paths": ["/usr/share/mime/"],
     "run": "update-mime-database /usr/share/mime"},
    {"name": "systemd-daemon-reload", "paths": ["/usr/lib/systemd/system/"],
     "run": "systemctl daemon-reload"},
    # `systemctl --global daemon-reload` NIE istnieje – --global dotyczy tylko
    # enable/disable jednostek. Przeładowanie robi _user_daemon_reload()
    # (per zalogowany użytkownik), a "run" zostaje jako opis/cel audytu.
    {"name": "systemd-user-daemon-reload", "paths": ["/usr/lib/systemd/user/"],
     "internal": "user-daemon-reload",
     "run": "systemctl --user daemon-reload"},
    {"name": "udev-reload", "paths": ["/usr/lib/udev/rules.d/"],
     "run": "udevadm control --reload-rules"},
]

def _load_triggers() -> List[dict]:
    """Ładuje triggery: domyślne (tylko gdy binarka istnieje) + /etc/pag/triggers/*.json."""
    out = []
    for t in DEFAULT_TRIGGERS:
        bin_name = t["run"].split()[0]
        if shutil.which(bin_name):
            out.append(dict(t))
    if os.path.isdir(TRIGGERS_DIR):
        for fn in sorted(os.listdir(TRIGGERS_DIR)):
            if not fn.endswith(".json"):
                continue
            try:
                with open(os.path.join(TRIGGERS_DIR, fn)) as f:
                    data = json.load(f)
            except (OSError, json.JSONDecodeError):
                continue
            if isinstance(data, dict):
                data = [data]
            for t in data:
                if isinstance(t, dict) and t.get("name") and t.get("paths") and t.get("run"):
                    out.append(t)
    return out

def _logged_in_users() -> List[tuple]:
    """[(uid, user)] aktywnych logowań wg loginctl. Best-effort."""
    try:
        r = subprocess.run(["loginctl", "list-users", "--no-legend"],
                           capture_output=True, text=True, timeout=30)
    except Exception:
        return []
    out = []
    for ln in (r.stdout or "").splitlines():
        parts = ln.split()
        if len(parts) < 2 or not parts[0].isdigit():
            continue
        out.append((parts[0], parts[1]))
    return out


def _user_daemon_reload() -> int:
    """Przeładowuje menedżery systemd ZALOGOWANYCH użytkowników.

    `systemctl --user` działa tylko w kontekście danego użytkownika (sesyjny
    D-Bus), więc dla roota trzeba wejść w jego sesję. Zwraca liczbę udanych
    przeładowań; brak sesji to nie błąd – jednostki wczytają się przy logowaniu.
    """
    done = 0
    for uid, user in _logged_in_users():
        rt = f"/run/user/{uid}"
        if not os.path.isdir(rt):
            continue
        try:
            if shutil.which("runuser"):
                r = subprocess.run(
                    ["runuser", "-u", user, "--", "env", f"XDG_RUNTIME_DIR={rt}",
                     "systemctl", "--user", "daemon-reload"],
                    capture_output=True, timeout=60)
            else:
                r = subprocess.run(
                    ["su", "-", user, "-c",
                     f"XDG_RUNTIME_DIR={rt} systemctl --user daemon-reload"],
                    capture_output=True, timeout=60)
            if r.returncode == 0:
                done += 1
        except Exception:
            pass
    return done


def _reload_user_media_services(touched_paths: List[str]) -> None:
    """Po aktualizacji multimediow przeladuj uslugi UZYTKOWNIKA (pipewire/wireplumber).

    Nowe binarki/moduly sa juz na dysku, ale dzialajace sesje maja stare w
    pamieci i probuja ladowac nieistniejace wersje modulow. Best-effort:
    przeladowanie menedzerow systemd uzytkownikow + try-restart w sesjach.
    """
    if os.environ.get("PAG_NO_HOOKS", "") == "1":
        return
    _pfx = ("/usr/lib/systemd/user/pipewire", "/usr/lib/systemd/user/wireplumber",
            "/usr/bin/pipewire", "/usr/bin/wireplumber",
            "/usr/lib/pipewire-0.3/", "/usr/lib64/pipewire-0.3/",
            "/usr/lib/wireplumber-0.5/", "/usr/lib64/wireplumber-0.5/")
    if not any(_p.startswith(_x) for _x in _pfx for _p in touched_paths):
        return
    _user_daemon_reload()
    try:
        _r = subprocess.run(["loginctl", "list-users", "--no-legend"],
                            capture_output=True, text=True, timeout=30)
        _users = [ln.split()[1] for ln in (_r.stdout or "").splitlines()
                  if len(ln.split()) >= 2]
    except Exception:
        _users = []
    _done = []
    for _u in _users:
        try:
            _rr = subprocess.run(
                ["su", "-", _u, "-c",
                 "systemctl --user try-restart pipewire.socket pipewire.service "
                 "wireplumber.service"],
                capture_output=True, timeout=60)
            if _rr.returncode == 0:
                _done.append(_u)
        except Exception:
            pass
    if _done:
        print(_("audio_services_reloaded", ", ".join(sorted(set(_done)))))

def _process_triggers(touched_paths: List[str]):
    """Uruchamia pasujące triggery RAZ na końcu transakcji (best-effort)."""
    if not touched_paths:
        return
    if os.environ.get("PAG_NO_HOOKS", "") == "1":
        return
    import shlex as _shlex
    matched = []
    for trig in _load_triggers():
        if any(path.startswith(p) for p in trig["paths"] for path in touched_paths):
            matched.append(trig)
    for trig in matched:
        run = trig["run"]
        print(_('  ⚡ Trigger: {arg1} ({arg2})', arg1=(trig['name']), arg2=(run)))
        if trig.get("internal") == "user-daemon-reload":
            _n = _user_daemon_reload()
            _audit(f"TRIGGER {trig['name']}: user-daemon-reload ok={_n}")
            if not _n:
                print("    ℹ " + _('no_user_sessions'))
            continue
        try:
            r = subprocess.run(_shlex.split(run), capture_output=True, text=True, timeout=120)
            _audit(f"TRIGGER {trig['name']}: {run} rc={r.returncode}")
            if r.returncode != 0:
                print(f"    ⚠ rc={r.returncode}: {(r.stderr or r.stdout or '').strip()[:160]}")
        except subprocess.TimeoutExpired:
            print(_('    ⚠ trigger {arg1} timed out (120 s)', arg1=(trig['name'])))
            _audit(f"TRIGGER {trig['name']} TIMEOUT")
        except Exception as e:
            print(_('    ⚠ trigger {arg1}: {arg2}', arg1=(trig['name']), arg2=(e)))
    _reload_user_media_services(touched_paths)


# =============================================================================
# UPDATE / UPGRADE / LIST / SEARCH / INFO / VERIFY
# =============================================================================

def _cleanup_tmp_files(*paths):
    """Usuwa tymczasowe pliki (np. .pag.new) po nieudanej operacji."""
    for p in paths:
        try:
            if os.path.isfile(p):
                os.remove(p)
        except OSError:
            pass


def cmd_self_update():
    """Aktualizuje samego klienta pag z repo (podpisany /stable/pag).

    Kolejność: pobierz → weryfikacja GPG (+ fingerprint repo) → SHA256 →
    kontrola składni (compile) → backup → atomowe os.replace.

    Podmieniamy plik, z którego pag ZOSTAŁ URUCHOMIONY (a nie hardkodowane
    /usr/local/bin/pag): gdy pakiet instaluje /usr/bin/pag, a self-update
    pisał do /usr/local/bin/pag, powstawały DWIE kopie o różnych wersjach
    i zależnie od PATH `pag --version` pokazywał raz jedną, raz drugą."""
    # Dedykowana blokada – patrz SelfUpdateLock. Chroni zapis dst.new oraz
    # os.replace przed równoległą aktualizacją (np. cron + ręcznie).
    with SelfUpdateLock():
        return _self_update_impl()


def _self_update_impl():
    repos = get_repos()
    if not repos:
        print(_('❌ No repositories configured.'))
        return 1
    # Aktualizuj bieżący plik (Python ≥3.9 ustawia __file__ jako ścieżkę
    # bezwzględną). Poza /usr|/usr/local (np. uruchomienie z checkoutu)
    # nie nadpisujemy niczego – wracamy do domyślnej lokalizacji instalacji.
    dst = "/usr/local/bin/pag"
    try:
        cand = os.path.realpath(__file__)
        if cand.startswith(("/usr/", "/usr/local/")):
            dst = cand
    except Exception:
        pass
    base = repos[0]
    dst_new = dst + ".new"
    dst_bak = dst + ".bak"
    print(_('🔄 Checking for pag update from {arg1}...', arg1=(base)))
    try:
        with urlopen(Request(f"{base}/pag", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
            data = r.read()
        with urlopen(Request(f"{base}/pag.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
            sig = r.read()
    except Exception as e:
        print(_('  ❌ Cannot download pag: {arg1}', arg1=(e)))
        return 1

    # Zapisz nową wersję w katalogu docelowym (ta sama partycja → atomowy rename)
    with open(dst_new, "wb") as f:
        f.write(data)
    with open(dst_new + ".asc", "wb") as f:
        f.write(sig)

    # --- 1. Weryfikacja podpisu GPG – bez tego nie instalujemy ---
    insecure = os.environ.get("PAG_INSECURE", "") == "1"
    ok, fp = _gpg_verify_fp(dst_new + ".asc", dst_new)
    if not ok:
        # Automatyczny import klucza (TOFU) – jak w _verify_repo_sig
        res = _gpg_run("--verify", dst_new + ".asc", dst_new,
                       capture_output=True, text=True)
        _stderr = res.stderr.decode(errors="replace") if isinstance(res.stderr, bytes) else (res.stderr or "")
        if "public key" in _stderr.lower() and "no public key" in _stderr.lower():
            try:
                with urlopen(Request(f"{base}/paganos.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
                    keydata = r.read()
                with tempfile.NamedTemporaryFile(delete=False, suffix=".asc") as tmp:
                    tmp.write(keydata); tmp.flush()
                    _gpg_run("--import", tmp.name, capture_output=True, timeout=30)
                    os.unlink(tmp.name)
                print(_('  🔑 Imported repo key from {arg1}/paganos.asc', arg1=(base)))
                ok, fp = _gpg_verify_fp(dst_new + ".asc", dst_new)
            except Exception:
                pass
        if not ok:
            if insecure:
                print(_('  ⚠ Invalid update signature (PAG_INSECURE – ignoring)'))
            else:
                print(_('  ❌ Invalid update signature – not updating.'))
                _cleanup_tmp_files(dst_new, dst_new + ".asc")
                return 1
    # Sprawdź fingerprint względem przypiętego klucza repo
    pinned = _repo_pinned_fp(base)
    if pinned:
        if not fp:
            print(_('  ❌ Cannot confirm the update signature fingerprint.'))
            _cleanup_tmp_files(dst_new, dst_new + ".asc")
            return 1
        if fp != pinned.upper():
            if insecure:
                print(_('  ⚠ Update signed with a different key (PAG_INSECURE – ignoring)'))
            else:
                print(_('  ❌ [SECURITY ERROR] Update signed with a different key than the repo!'))
                print(_('     Expected: {arg1}, received: {arg2}', arg1=(pinned), arg2=(fp)))
                _cleanup_tmp_files(dst_new, dst_new + ".asc")
                return 1

    # --- 2. Weryfikacja SHA256 (jeśli repo publikuje pag.sha256) ---
    try:
        with urlopen(Request(f"{base}/pag.sha256", headers={"User-Agent": "pag/3.0"}), timeout=15) as r:
            sha = r.read().decode().strip().split()[0]
        if sha:
            actual = hashlib.sha256(data).hexdigest()
            if actual.lower() != sha.lower():
                print(_('  ❌ SHA256 mismatch! Expected {arg1}, got {arg2}', arg1=(sha), arg2=(actual)))
                _cleanup_tmp_files(dst_new, dst_new + ".asc")
                return 1
            print(_('  ✅ SHA256 matches'))
    except Exception:
        # Brak pag.sha256 w repo – opcjonalne; nie blokuj aktualizacji.
        pass

    # --- 3. Kontrola składni (nie uruchamiaj uszkodzonego/poddanego edycji pliku) ---
    try:
        compile(data, "pag", "exec")
    except SyntaxError as e:
        print(_('  ❌ Syntax error in new pag: {arg1}', arg1=(e)))
        _cleanup_tmp_files(dst_new, dst_new + ".asc")
        return 1

    m = (re.search(rb'PAG_VERSION\s*=\s*"(\d+\.\d+\.\d+[a-z]?)"', data[:3000])
         or re.search(rb"v(\d+\.\d+\.\d+[a-z]?)", data[:3000]))
    new_ver = m.group(1).decode() if m else "?"
    print(_('  ✅ Downloaded pag {arg1} (current {arg2}), signature verified', arg1=(new_ver), arg2=(PAG_VERSION)))

    # --- 4. Backup + atomowa podmiana ---
    if os.path.exists(dst):
        shutil.copy2(dst, dst_bak)
    os.chmod(dst_new, 0o755)
    os.replace(dst_new, dst)  # atomowe na tym samym FS
    try:
        if os.path.exists(dst_new + ".asc"):
            os.remove(dst_new + ".asc")
    except OSError:
        pass
    print(_('  ✅ Installed new pag. Old version kept as {arg1}', arg1=(dst_bak)))
    # Ostrzeż, gdy w PATH pierwsza jest INNA kopia `pag` – inaczej
    # `pag --version` dalej pokaże starą wersję i wygląda to jak brak update.
    other = shutil.which("pag")
    if other and os.path.realpath(other) != os.path.realpath(dst):
        print(_('  ⚠ A different pag is first in PATH: {arg1} (updated {arg2})', arg1=(other), arg2=(dst)))
        print(_('     Remove the old copy: sudo rm {arg1}', arg1=(other)))
    print(_('   Restart pag to use the new version.'))
    return 0


def _candidate_newer(rp, inst):
    """Czy pakiet z repo jest nowszy od zainstalowanego.
    Porównuje (version, release): sam bump pkgrel (np. auto-rebuild modułów
    po aktualizacji jądra: nvidia-kernel-618 610.57.04-1 -> -2) też musi być
    widziany przez `pag update`. Stare rekordy instalacji (bez pola release)
    traktujemy jak release=1 – nie generują churnu, dopóki nie wrócą do
    reinstalacji/zmiany wersji."""
    rv = getattr(rp, "version", "0")
    iv = inst.get("version", "0")
    if _version_newer(rv, iv):
        return True
    if rv != iv:
        return False
    rr = int(getattr(rp, "release", 1) or 1)
    ir = int(inst.get("release", 1) or 1)
    return rr > ir


def _pending_updates() -> List[str]:
    """Zainstalowane pakiety z nowszą wersją/release w repo (bez przypiętych)."""
    installed = load_json(INSTALLED_DB)
    pinned = load_json(PINNED_FILE)
    repo = fetch_all_packages()
    if not repo:
        return []
    return [n for n, i in installed.items()
            if n not in pinned and (rp := repo.get(n)) and _candidate_newer(rp, i)]

# =============================================================================
# BAZA Z OBRAZU ISO → REPO (`pag base`) – pełny rolling
# =============================================================================
# ISO jest zbudowane ZE ŹRÓDEŁ (glibc, gcc, gtk, XFCE, …) – pag tych pakietów
# nie instalował, więc nie ma ich w installed.json/files.db. Skutki:
#   • `pag upgrade` ich NIE dotyka (nie ma o nich pojęcia),
#   • mimo to `pag install <nazwa>` je NADPISZE – pag robi kopię plików spoza
#     swojej bazy (patrz _new_transaction_backup_root), więc nie są nietykalne.
#
# /usr/share/pag/base.json (wypalany przez build-pagan.sh) mówi, co jest w bazie
# obrazu i w jakiej wersji. `pag base` pokazuje stan, a `pag base adopt` dogrywa
# te pakiety z repo – po tym zabiegu pag zarządza nimi normalnie, więc
# `pag upgrade` aktualizuje CAŁY system (rolling), a nie tylko to, co sam
# wcześniej zainstalował.
#
# Nazwy z buildera różnią się od nazw pakietów w repo (builder buduje „libX11”,
# repo ma pakiet „xorg-libx11”), stąd aliasy poniżej. Nazwy bez odpowiednika
# w repo zostają w wersji z obrazu – raport mówi o tym wprost, zamiast udawać,
# że są aktualne.
BASE_NAME_ALIASES = {
    "atk": "at-spi2-core",
    "dejavu-fonts": "dejavu-ttf",
    "fontconfig": "xorg-fontconfig",
    "gtk": "gtk3",
    "iceauth": "xorg-iceauth",
    "libX11": "xorg-libx11",
    "libXau": "xorg-libxau",
    "libXdmcp": "xorg-libxdmcp",
    "libXext": "xorg-libxext",
    "libXft": "xorg-libxft",
    "libdrm": "xorg-libdrm",
    "libnspr": "nspr",
    "libxkbfile": "xorg-libxkbfile",
    "libxklavier": "xorg-libxklavier",
    "linux-pam": "pam",
    "pixman": "xorg-pixman",
    "sdl2": "sdl",
    "setxkbmap": "xorg-setxkbmap",
    "xauth": "xorg-xauth",
    "xf86-input-libinput": "xorg-xf86-input-libinput",
    "xf86-video-fbdev": "xorg-xf86-video-fbdev",
    "xinit": "xorg-xinit",
    "xkbcomp": "xorg-xkbcomp",
    "xkeyboard-config": "xorg-xkeyboard-config",
    # Builder buduje wpa_supplicant (z podkreślnikiem), a repo ma wpa-supplicant
    # (z myślnikiem) – bez tego aliasu pakiet nie dostawał aktualizacji z repo,
    # mimo że repo.json zna DOKŁADNIE tę samą wersję.
    "wpa_supplicant": "wpa-supplicant",
}


def _base_manifest() -> dict:
    """Manifest bazy z obrazu ({} gdy obraz go nie dostarcza)."""
    _d = load_json(os.path.join(PAG_ROOT, BASE_MANIFEST.lstrip("/")))
    return _d if isinstance(_d, dict) else {}


def _base_entries() -> list:
    """[(nazwa_z_buildera, wersja_z_obrazu), ...] z manifestu."""
    _out = []
    for _e in (_base_manifest().get("packages") or []):
        if isinstance(_e, str):
            if _e:
                _out.append((_e, "?"))
        elif isinstance(_e, dict) and _e.get("name"):
            _out.append((str(_e["name"]), str(_e.get("version") or "?")))
    return _out


def _base_repo_name(name: str, repo: dict, installed: dict) -> str:
    """Nazwa pakietu w repo dla nazwy z buildera (alias → provides → brak)."""
    if name in repo:
        return name
    _alias = BASE_NAME_ALIASES.get(name)
    if _alias and _alias in repo:
        return _alias
    _real = _resolve_provides(name, repo, installed)
    return _real if _real in repo else ""


def _base_summary(repo: Optional[dict] = None) -> dict:
    """Klasyfikacja pakietów bazy z obrazu wobec repo.

    repo=None → pobiera indeks repo (potrzebny do listy „do adoptowania”).
    repo={}   → bez sieci: rozpoznaje tylko to, czym pag już zarządza.
    """
    _entries = _base_entries()
    if not _entries:
        return {"total": 0, "tracked": 0, "adoptable": [], "unmatched": []}
    if repo is None:
        repo = fetch_all_packages()
    installed = load_json(INSTALLED_DB)
    tracked, adoptable, unmatched = 0, [], []
    for _n, _v in _entries:
        _real = _base_repo_name(_n, repo, installed)
        if _n in installed or (_real and _real in installed):
            tracked += 1
        elif _real:
            adoptable.append((_n, _real, _v))
        else:
            unmatched.append(_n)
    return {"total": len(_entries), "tracked": tracked,
            "adoptable": adoptable, "unmatched": unmatched}


def _base_hint_unmanaged() -> None:
    """Jednozdaniowa informacja dla `pag sync/update/upgrade`."""
    try:
        _s = _base_summary()
    except Exception:
        return
    if _s["adoptable"]:
        print(f"\n  ℹ {_('base_unmanaged_hint', len(_s['adoptable']))}")


def _base_warn_overwrite(names) -> None:
    """Ostrzeżenie w `pag install`, gdy pakiet pochodzi z bazy obrazu ISO."""
    _entries = _base_entries()
    if not _entries:
        return
    _known = set()
    for _n, _v in _entries:
        _known.add(_n)
        _al = BASE_NAME_ALIASES.get(_n)
        if _al:
            _known.add(_al)
    _hit = [n for n in names if n in _known]
    if _hit:
        _listed = ", ".join(_hit[:5]) + (" …" if len(_hit) > 5 else "")
        print(f"  ℹ {_('base_overwrite', _listed)}")


def cmd_base_status():
    """`pag base` / `pag base status` – co w systemie pochodzi z obrazu,
    czym pag już zarządza i co da się zaadoptować z repo."""
    _man = _base_manifest()
    if not _man:
        print(f"  ℹ {_('base_no_manifest')}")
        return 0
    _s = _base_summary()
    print(f"\n  {_c('bold', _('base_title'))}")
    print(f"  {'─' * 46}")
    _de = _man.get("de") or ""
    print(f"  {_('base_iso_version'):<34} {_man.get('iso_version', '?')}" + (f" ({_de})" if _de else ""))
    print(f"  {_('base_total'):<34} {_s['total']}")
    print(f"  {_('base_tracked'):<34} {_s['tracked']}")
    print(f"  {_('base_adoptable'):<34} {len(_s['adoptable'])}")
    print(f"  {_('base_unmatched'):<34} {len(_s['unmatched'])}")
    if _s["adoptable"]:
        print(f"\n  {_('base_adopt_hint')}")
        for _iso_n, _real, _v in _s["adoptable"][:10]:
            _m = "" if _iso_n == _real else f"  ({_iso_n})"
            print(f"    {_real}-{_v}{_m}")
        if len(_s["adoptable"]) > 10:
            print(f"    … {len(_s['adoptable']) - 10} {_('base_more')}")
    if _s["unmatched"]:
        print(f"\n  {_('base_unmatched_hint')}")
        print("    " + ", ".join(_s["unmatched"][:12])
              + (f" … +{len(_s['unmatched']) - 12}" if len(_s["unmatched"]) > 12 else ""))
    return 0


def cmd_base_adopt(args):
    """`pag base adopt [pkg...] [--dry-run]` – dograj bazę z obrazu z repo.

    Pakiety bazy nie ma w installed.json, więc pag traktuje je jak NOWĄ
    instalację: pliki z obrazu trafiają do kopii transakcji (działa
    `pag rollback`), a po sukcesie pag zarządza nimi jak każdym innym pakietem.
    """
    if not _base_manifest():
        print(f"  ℹ {_('base_no_manifest')}")
        return 1
    repo = fetch_all_packages()
    if not repo:
        print(f"❌ {_('no_index')}")
        return 1
    _want = [a for a in args if not a.startswith("-") and a != "adopt"]
    _s = _base_summary(repo)
    plan = _s["adoptable"]
    if _want:
        _sel = set(_want)
        plan = [p for p in plan if p[0] in _sel or p[1] in _sel]
        if not plan:
            print(f"  ℹ {_('base_nothing_selected')}")
            return 0
    if not plan:
        print(f"✅ {_('base_all_managed')}")
        return 0
    _size = sum(repo[r].size_bytes for _i, r, _v in plan if r in repo)
    print(f"\n  {_('base_adopt_plan', len(plan), _size / 1048576)}")
    for _iso_n, _real, _v in plan[:20]:
        _p = repo.get(_real)
        _rv = _p.version if _p else "?"
        _rr = (getattr(_p, "release", "") or "") if _p else ""
        _rvr = f"{_rv}-{_rr}" if _rr else _rv
        _m = "" if _iso_n == _real else f"   ({_iso_n} → {_real})"
        print(f"    {_real}: {_v} → {_rvr}{_m}")
    if len(plan) > 20:
        print(f"    … {len(plan) - 20} {_('base_more')}")
    if "-n" in args or "--dry-run" in args:
        print(f"  {_('base_dry_run')}")
        return 0
    _rc = cmd_install([r for _i, r, _v in plan])
    if _rc == 0:
        # Wymienione biblioteki/narzędzia (glibc, gcc, GTK…) są już nowe na dysku,
        # ale działające procesy wciąż mają stare w pamięci – restart domyka.
        print(f"\n  ℹ {_('base_reboot_hint')}")
    return _rc


def _base_cached_index() -> dict:
    """Indeks repo TYLKO z lokalnego cache (zero sieci) – do mapowania nazw.

    Potrzebne dla `pag base register`: rejestracja bazy obrazu nie może zależeć
    od sieci (odpala się w buildzie, w chroocie, bez DNS). Cache indeksu powstaje
    przy okazji `pag sync`/`pag install` i po nim wystarcza.
    """
    _out = {}
    try:
        for _r in get_repos():
            _cp = _repo_cache_path(_r)
            if not os.path.exists(_cp):
                continue
            for _pdata in (_load_repo_cache(_cp) or []):
                _n = _pdata.get("name") or _pdata.get("filename", "?").split("-")[0]
                _pkg = PackageInfo(_pdata, _r)
                if _n not in _out or _version_newer(_pkg.version, _out[_n].version):
                    _out[_n] = _pkg
    except Exception:
        return _out
    return _out


def cmd_base_register(args):
    """`pag base register [--force] [--dry-run]` – wpisz bazę obrazu do installed.json.

    PO CO: pakietów zbudowanych przez builder (glibc, gcc, GTK, XFCE…) nie ma
    w installed.json, więc `pag upgrade` ich NIE widzi i system nie da się
    prowadzić w trybie rolling – trzeba by najpierw `pag base adopt`, czyli
    ponownie ŚCIĄGNĄĆ całą bazę z repo. Rejestracja zamiast tego zapisuje je
    jako zainstalowane **z wersją z obrazu** (to ona leży na dysku), więc
    `pag upgrade` porówna ją z repo i podniesie tylko to, co nowsze.

    Offline: nic nie pobiera. Cache indeksu repo (jeśli jest) służy WYŁĄCZNIE do
    mapowania nazw builder → repo (BASE_NAME_ALIASES/provides) i metadanych
    (release/opis/zależności). Nazwy bez odpowiednika w repo zostają jak są.

    OGRANICZENIE: rejestracja nie zna listy plików pakietu (files.db), więc
    dopóki pakiet nie zostanie zaktualizowany z repo, `pag verify`/`pag remove`
    go nie obejmą (`pag base adopt` nadal jest drogą do pełnego przejęcia).
    """
    _force = "-f" in args or "--force" in args
    _dry = "-n" in args or "--dry-run" in args

    _entries = _base_entries()
    if not _entries:
        print(f"  ℹ {_('base_no_manifest')}")
        return 1

    _repo = _base_cached_index()
    installed = load_json(INSTALLED_DB)
    world = load_world()
    _now = datetime.now().isoformat()

    added, skipped, renamed = [], 0, 0
    for _n, _v in _entries:
        _real = _base_repo_name(_n, _repo, installed) if _repo else ""
        _key = _real or _n
        if _real and _real != _n:
            renamed += 1
        if _key in installed and not _force:
            skipped += 1
            continue
        _pkg = _repo.get(_key)
        installed[_key] = {
            "version": _v or (getattr(_pkg, "version", "") or "?"),
            "release": getattr(_pkg, "release", "") or "1",
            "description": (getattr(_pkg, "description", "") or "")
                           or "Pagan Linux – pakiet bazy obrazu",
            "dependencies": list(getattr(_pkg, "dependencies", []) or []),
            "size_bytes": getattr(_pkg, "size_bytes", 0) or 0,
            "sha256": "",
            "installed_at": _now,
            "repo": "base",
            "provides": list(getattr(_pkg, "provides", []) or []),
            "provides_so": list(getattr(_pkg, "provides_so", []) or []),
            "requires_so": list(getattr(_pkg, "requires_so", []) or []),
        }
        world.add(_key)
        added.append(_key)

    if _dry:
        print(f"  ℹ {_('base_register_plan', len(added))}")
        return 0
    if added:
        save_json(INSTALLED_DB, installed)
        save_world(world)
    print(f"  ✅ {_('base_register_ok', len(added), skipped)}")
    if renamed:
        print(f"  ℹ {_('base_register_renamed', renamed)}")
    if not _repo:
        print(f"  ℹ {_('base_register_nocache')}")
    return 0


def cmd_update(do_upgrade: bool = False):
    """`pag sync` / `pag update` – odświeżenie indeksów + raport aktualizacji.

    sync   → tylko odświeżenie indeksów + info: „jest X pakietów do
             zaktualizowania – wpisz: pag update".
    update → odświeżenie indeksów + AKTUALIZACJA PAKIETÓW (pakiety, nie system).
    Pomijamy cache TTL (inaczej nowe pakiety/aktualizacje są niewidoczne nawet
    przez godzinę). Pełne pobranie + weryfikacja GPG przy każdym odświeżeniu.
    """
    force = True
    print(_('🔄 Refreshing indexes...'))
    for repo_url in get_repos():
        pkgs = fetch_repo_index(repo_url, force=force)
        cp = _repo_cache_path(repo_url)
        has_sig = os.path.exists(cp + ".sig")
        print(_('  {arg1} {arg2}: {arg3} packages {arg4}', arg1=('✅' if pkgs is not None else '❌'), arg2=(repo_url), arg3=(len(pkgs or [])), arg4=('🔐' if has_sig else '⚠')))
    print(f"✅ {_('indexes_refreshed')}")

    # Powiadomienie o nowszej wersji pag (repo.json["pag_version"])
    try:
        for r in get_repos():
            cp = _repo_cache_path(r)
            if os.path.exists(cp):
                d = json.load(open(cp))
                rv = d.get("pag_version", "")
                if rv and rv != PAG_VERSION:
                    print(_('  ⚠ New pag version {arg1} available – run: pag self-update', arg1=(rv)))
    except Exception:
        pass

    # Raport: pakiety do aktualizacji
    pending = _kernel_group_updates(_pending_updates())
    if not pending:
        print(f"✅ {_('all_up_to_date')}")
        # `pag upgrade` ma sens także wtedy, gdy pakiety pag są aktualne –
        # Flatpaki żyją własnym cyklem wydawniczym.
        if do_upgrade:
            _flatpak_auto_update()
        _base_hint_unmanaged()
        return 0
    print(f"{_('updates_available', len(pending))}")
    installed = load_json(INSTALLED_DB)
    repo = fetch_all_packages()
    for n in pending:
        _i = installed.get(n, {})
        _ir = _i.get("release")
        _nr = getattr(repo[n], "release", "") or ""
        _old = f"{_i.get('version', '?')}-{_ir}" if _ir else _i.get("version", "?")
        _new = f"{repo[n].version}-{_nr}" if _nr else repo[n].version
        print(f"   {n}: {_old} → {_new}")
    if not do_upgrade:
        _base_hint_unmanaged()
        return 0  # sync: tylko informacja
    if not _ask_confirm():
        return 0
    _rc = cmd_install(pending, upgrade=True)
    _base_hint_unmanaged()
    # Flatpaki PO pakietach pag: błąd Flatpaka nie zmienia wyniku transakcji.
    _flatpak_auto_update()
    return _rc

def _versioned_kernels(boot: str = "/boot") -> list:
    """Wersjonowane obrazy jąder z /boot (bez aliasu `vmlinuz-linux`)."""
    try:
        out = []
        for n in os.listdir(boot):
            if not n.startswith("vmlinuz-"):
                continue
            ver = n[len("vmlinuz-"):]
            if not ver or not ver[0].isdigit():
                continue            # vmlinuz-linux to alias, nie wersja
            if os.path.islink(os.path.join(boot, n)):
                continue
            out.append(ver)
        return out
    except Exception:
        return []


def _initramfs_stale() -> bool:
    """Czy initramfs najnowszego (wersjonowanego) jądra wymaga przebudowy.

    Uwaga: aliasy `initramfs.img` / `initramfs-linux.img` bywają martwymi
    symlinkami — `os.path.exists()` zwraca wtedy False, co wcześniej kończyło
    się wiecznym „stale” i przebudową w pętli. Patrzymy na KONKRETNY plik
    `initramfs-<wersja>.img`.
    """
    try:
        if not os.path.isdir("/boot"):
            return False
        vers = _versioned_kernels()
        if not vers:
            return False
        newest = max(vers, key=lambda v: os.path.getmtime(f"/boot/vmlinuz-{v}"))
        img = f"/boot/initramfs-{newest}.img"
        if not os.path.isfile(img):
            return True
        return os.path.getmtime(img) < os.path.getmtime(f"/boot/vmlinuz-{newest}")
    except Exception:
        return False

def cmd_upgrade():
    """`pag upgrade` – aktualizacja SYSTEMU: pakiety + kernel/initramfs/GRUB."""
    rc = cmd_update(do_upgrade=True)
    if rc != 0:
        return rc
    # System: dopilnuj initramfs (gdyby kernel był nowszy) + GRUB.
    if _initramfs_stale():
        print(_('  🐧 Rebuilding initramfs (newer kernel)...'))
        _rebuild_initramfs()
    _refresh_bootloader()
    return 0

def cmd_list(installed_only=False):
    if installed_only:
        db = load_json(INSTALLED_DB)
        pinned = load_json(PINNED_FILE)
        if not db: print(_('No packages installed.')); return
        print(_('Installed ({arg1}):', arg1=(len(db))))
        for n, i in sorted(db.items()):
            pin = " 📌" if n in pinned else ""
            print(f"  {n}-{i['version']}{pin}  – {i.get('description','')}")
    else:
        pkgs = fetch_all_packages()
        installed = load_json(INSTALLED_DB)
        pinned = load_json(PINNED_FILE)
        print(_('Available ({arg1}):', arg1=(len(pkgs))))
        for n, p in sorted(pkgs.items()):
            m = "✓" if n in installed else " "
            extra = f"  [{_('installed_marker')}: {installed[n]['version']}]" if n in installed else ""
            if n in pinned: extra += " 📌"
            print(f"  [{m}] {n}-{p.version}  – {p.description}{extra}")

def cmd_search(query):
    pkgs = fetch_all_packages()
    results = [(n,p) for n,p in pkgs.items() if query.lower() in n.lower() or query.lower() in p.description.lower()]
    if not results: print(_('❌ No results for: {arg1}', arg1=(query))); return
    installed = load_json(INSTALLED_DB)
    print(_("Results for '{arg1}' ({arg2}):", arg1=(query), arg2=(len(results))))
    for n,p in sorted(results):
        print(f"  [{'✓' if n in installed else ' '}] {n}-{p.version}")
        print(f"      {p.description}")


def _smart_search(query: str) -> int:
    """
    Inteligentne wyszukiwanie: repo PaganOS + Flathub.
    Uruchamiane gdy użytkownik wpisze `pag <nazwa>` zamiast `pag install <nazwa>`.
    Pokazuje dostępne źródła i sugeruje komendy instalacji.
    """
    # 1. Repo PaganOS
    try:
        pkgs = fetch_all_packages()
    except Exception:
        pkgs = {}
    repo_lower = [(n, p) for n, p in pkgs.items()
                  if query.lower() in n.lower() or query.lower() in p.description.lower()]

    # 2. Flathub (jeśli dostępny)
    flat = _flatpak_search_raw(query) if _check_flatpak(quiet=True) else []

    if not repo_lower and not flat:
        print(_("\n  ❌ '{arg1}' — not found.", arg1=(query)))
        print(_('     PaganOS repo: pag search {arg1}', arg1=(query)))
        if _check_flatpak(quiet=True):
            print(_('     Flathub:      pag flatpak search {arg1}', arg1=(query)))
        print(_('     Add repo:     pag repo-add <url>'))
        return 1

    installed = load_json(INSTALLED_DB)

    # ── Repo PaganOS ──
    if repo_lower:
        exact = [(n, p) for n, p in repo_lower if n.lower() == query.lower()]
        show = (exact or repo_lower)[:6]
        print(f"\n  📦 PaganOS — '{query}':")
        for n, p in sorted(show):
            mark = "✓" if n in installed else " "
            desc = p.description[:70] if len(p.description) > 75 else p.description
            print(f"  [{mark}] {n}-{p.version}")
            if desc:
                print(f"      {desc}")
        if len(repo_lower) > 6:
            print(_('      ... and {arg1} more (pag search {arg2})', arg1=(len(repo_lower) - 6), arg2=(query)))

    # ── Flathub ──
    if flat:
        print(f"\n  📦 Flathub — '{query}':")
        for r in flat[:5]:
            mark = "✓" if r.get("installed") else " "
            name = r.get("name") or r.get("application", "?")
            desc = (r.get("description") or "")[:65]
            print(f"  [{mark}] {name}")
            if desc:
                print(f"      {desc}")
        if len(flat) > 5:
            print(_('      ... and {arg1} more (pag flatpak search {arg2})', arg1=(len(flat) - 5), arg2=(query)))

    # ── Sugestie instalacji ──
    print()
    if repo_lower:
        best = sorted(repo_lower, key=lambda x: (x[0].lower() != query.lower(), -len(x[1].name if hasattr(x[1], 'name') else 0)))[0][0]
        if best in installed:
            print(_('  ✓ {arg1} is already installed ({arg2})', arg1=(best), arg2=(installed[best]['version'])))
        else:
            print(f"  💡 sudo pag install {best}")
    if flat:
        best_fp = flat[0].get("application") or flat[0].get("name", query)
        print(f"  💡 pag flatpak install {best_fp}")

    return 0

def cmd_info(name):
    pkgs = fetch_all_packages()
    p = pkgs.get(name)
    info = load_json(INSTALLED_DB).get(name)
    if not p and not info: print(_("❌ '{arg1}' not found.", arg1=(name))); return 1
    print(f"📦 {name}")
    if p:
        print(_('   Version (repo):  {arg1}', arg1=(p.version)))
        print(_('   Description:     {arg1}', arg1=(p.description)))
        print(_('   Size:            {arg1:.1f} MB', arg1=(p.size_bytes/1048576)))
        print(_('   SHA256:          {arg1}...', arg1=(p.sha256[:32])))
        print(_('   GPG:             {arg1}', arg1=(p.gpg_fp or _('none_value'))))
        print(_('   Dependencies:    {arg1}', arg1=((', '.join(p.dependencies)) if p.dependencies else _('none_parenthesized'))))
        if p.optdepends:
            print(f"   {_('optional_deps')}")
            for _od in p.optdepends:
                print(f"     - {_od}")
    if info:
        print(_('   Installed:       {arg1} ({arg2})', arg1=(info['version']), arg2=(info.get('installed_at','?'))))

def cmd_files(name):
    if name not in load_json(INSTALLED_DB):
        print(_("❌ '{arg1}' not installed.", arg1=(name))); return 1
    files = _db_get_package_files(name)
    print(_('Files in {arg1} ({arg2}):', arg1=(name), arg2=(len(files))))
    for f in sorted(files): print(f"  {f}")

def cmd_repair(dry_run=False):
    """Naprawia system: reinstaluje pakiety, ktorych pliki zginely.

    Przechodzi po bazie plikow (jak `verify`), zbiera pakiety z brakujacymi
    plikami i dla kazdego robi REINSTALACJE z repozytorium (staging + GPG).
    Reinstalacja nie rusza konfiguracji uzytkownika (.pacnew), a przywraca
    brakujace pliki pakietu (np. qt6-declarative, accountsservice).
    """
    installed = load_json(INSTALLED_DB)
    if not installed:
        print(_('Nothing to repair (no packages installed).'))
        return 0
    missing = {}
    for name in installed:
        cnt = 0
        for fpath in _db_get_package_files(name):
            full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
            if not (os.path.exists(full) or os.path.islink(full)):
                cnt += 1
        if cnt:
            missing[name] = cnt
    if not missing:
        print(_('✅ All files are in place – nothing to repair.'))
        return 0
    total = sum(missing.values())
    print(_('🔧 Packages with missing files: {arg1} (total {arg2} files)', arg1=(len(missing)), arg2=(total)))
    for n, c in sorted(missing.items(), key=lambda kv: (-kv[1], kv[0])):
        print(f"   {n}: {c}")
    if dry_run:
        print(_('\n(--dry-run: nothing is changed)'))
        return 0
    if not _ask_confirm():
        print(_("cancelled")); return 0
    # Jedna migawka na całą naprawę – nie tworzymy snapshotu per pakiet.
    _snap_ok, _ = _snapshot_support()
    if _snap_ok:
        _create_system_snapshot(list(missing), "repair")
        _refresh_bootloader()
    _prev_snap = os.environ.get("PAG_SNAPSHOT")
    os.environ["PAG_SNAPSHOT"] = "never"
    failed = []
    try:
        for n in sorted(missing, key=lambda x: (-missing[x], x)):
            print(_('\n🔧 repair: {arg1}', arg1=(n)))
            try:
                rc = cmd_install([n], upgrade=True)
            except SystemExit as e:
                rc = e.code
            except Exception as e:
                print(f"   ❌ {n}: {e}")
                rc = 1
            if rc:
                failed.append(n)
    finally:
        if _prev_snap is None:
            os.environ.pop("PAG_SNAPSHOT", None)
        else:
            os.environ["PAG_SNAPSHOT"] = _prev_snap
    print()
    ok = len(missing) - len(failed)
    if failed:
        print(_('⚠ Repaired {arg1}/{arg2}. Failed: {arg3}', arg1=(ok), arg2=(len(missing)), arg3=(', '.join(failed))))
        return 1
    print(_('✅ Repaired {arg1} packages.', arg1=(ok)))
    return 0


def cmd_verify(deep=False):
    installed = load_json(INSTALLED_DB)
    if not installed: print(_('Nothing to verify.')); return
    errors = []

    # Wczytaj WSZYSTKIE sumy RAZ (nie w pętli!) – przy 50k plików wywołanie
    # _db_get_all_file_checksums() per-plik dawało O(n²) i godziny zamiast sekund.
    all_checksums = _db_get_all_file_checksums() if deep else {}
    for name in installed:
        for fpath in _db_get_package_files(name):
            full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
            if not (os.path.exists(full) or os.path.islink(full)):
                errors.append(_("verify_missing_file", name, fpath))
            elif deep:
                expected = all_checksums.get(fpath, "")
                if expected:
                    actual = _sha256_file(full)
                    if actual != expected:
                        errors.append(_("verify_sha_mismatch", name, fpath))

    if errors:
        print(f"❌ {_('verify_errors', len(errors))}")
        for e in errors: print(e)
        return 1
    total = _db_count_files()
    print(f"✅ {_('verify_ok', total)}")

# =============================================================================
# PINNING / CLEAN / ORPHANS / REPO / FLATPAK
# =============================================================================

def cmd_pin(name, version=""):
    pinned = load_json(PINNED_FILE)
    if version:
        pinned[name] = version
    else:
        info = load_json(INSTALLED_DB).get(name, {})
        pinned[name] = info.get("version", "?")
    save_json(PINNED_FILE, pinned)
    print(f"📌 {name} {_('pinned_to')} {pinned[name]}")

def cmd_unpin(name):
    pinned = load_json(PINNED_FILE)
    if name in pinned:
        del pinned[name]; save_json(PINNED_FILE, pinned)
        print(f"🔓 {name} {_('unpinned')}")
    else:
        print(f"⚠ {name} {_('not_pinned')}")

def cmd_pinned():
    pinned = load_json(PINNED_FILE)
    if not pinned: print(_("no_pinned")); return
    print(_("pinned_list", len(pinned)))
    for n,v in sorted(pinned.items()): print(f"  📌 {n} = {v}")

def cmd_clean():
    if os.path.isdir(PAG_CACHE):
        count = size = 0
        for f in os.listdir(PAG_CACHE):
            fp = os.path.join(PAG_CACHE, f)
            if os.path.isfile(fp):
                size += os.path.getsize(fp); os.remove(fp); count += 1
        print(f"✅ {_('cache_cleared', count, size/1048576)}")

def cmd_remove_orphans():
    installed = load_json(INSTALLED_DB)
    world = load_world()
    orphans = _find_orphans(installed, world)
    if not orphans: print(_('✅ No orphans.')); return
    print(_('Orphans ({arg1}):', arg1=(len(orphans))))
    for n in sorted(orphans): print(f"  {n}-{installed[n]['version']}")
    if not _ask_confirm():
        return
    cmd_remove(list(orphans))


# =============================================================================
# PROVIDES – PAKIETY WIRTUALNE
# =============================================================================

PROVIDES_MAP = {
    "pkgconfig(glib-2.0)": "glib",
    "pkgconfig(gobject-introspection-1.0)": "gobject-introspection",
    "pkgconfig(gtk+-3.0)": "gtk",
    "pkgconfig(gtk4)": "gtk",
    "pkgconfig(zlib)": "zlib",
    "pkgconfig(libffi)": "libffi",
    "pkgconfig(expat)": "expat",
    "pkgconfig(libsystemd)": "systemd",
    "pkgconfig(dbus-1)": "dbus",
    "pkgconfig(mount)": "util-linux",
    "pkgconfig(blkid)": "util-linux",
    "pkgconfig(libcap)": "libcap",
    "pkgconfig(liblzma)": "xz",
    "pkgconfig(libzstd)": "zstd",
    "pkgconfig(bzip2)": "bzip2",
    "pkgconfig(libcurl)": "curl",
    "pkgconfig(openssl)": "openssl",
    "pkgconfig(libpcre2-8)": "pcre2",
    "pkgconfig(libxml-2.0)": "libxml2",
    "pkgconfig(libxslt)": "libxslt",
    "pkgconfig(freetype2)": "freetype",
    "pkgconfig(fontconfig)": "fontconfig",
    "pkgconfig(harfbuzz)": "harfbuzz",
    "pkgconfig(cairo)": "cairo",
    "pkgconfig(pango)": "pango",
    "pkgconfig(xt)": "xorg-libxt",
    "pkgconfig(xmu)": "xorg-libxmu",
    "pkgconfig(ice)": "xorg-libice",
    "pkgconfig(sm)": "xorg-libsm",
    "pkgconfig(x11)": "xorg-libx11",
    "pkgconfig(xext)": "xorg-libxext",
    "pkgconfig(xrandr)": "xorg-libxrandr",
    "pkgconfig(xfixes)": "xorg-libxfixes",
    "pkgconfig(xcursor)": "xorg-libxcursor",
    "pkgconfig(xinerama)": "xorg-libxinerama",
    "pkgconfig(xrender)": "xorg-libxrender",
    "pkgconfig(xau)": "xorg-libxau",
    "pkgconfig(xcb)": "xorg-libxcb",
    "pkgconfig(xdamage)": "xorg-libxdamage",
    "pkgconfig(xcomposite)": "xorg-libxcomposite",
    "pkgconfig(xft)": "xorg-libxft",
    "pkgconfig(xss)": "xorg-libxss",
    "pkgconfig(libsoup-3.0)": "libsoup3",
    "pkgconfig(libsoup-2.4)": "libsoup2",
    "pkgconfig(gdk-pixbuf-2.0)": "gdk-pixbuf2",
    "pkgconfig(libpng)": "libpng",
    "pkgconfig(libjpeg)": "libjpeg-turbo",
    "pkgconfig(libtiff-4)": "libtiff",
    "pkgconfig(ffi)": "libffi",
    # ── system / baza ──
    "pkgconfig(libcrypto)": "openssl",
    "pkgconfig(libssl)": "openssl",
    "pkgconfig(libudev)": "systemd",
    "pkgconfig(libmount)": "util-linux",
    "pkgconfig(libblkid)": "util-linux",
    "pkgconfig(uuid)": "util-linux",
    "pkgconfig(libexpat)": "expat",
    "pkgconfig(libpcre)": "pcre",
    "pkgconfig(ncursesw)": "ncurses",
    "pkgconfig(tinfo)": "ncurses",
    "pkgconfig(panel)": "ncurses",
    "pkgconfig(readline)": "readline",
    "pkgconfig(libseccomp)": "libseccomp",
    "pkgconfig(pam)": "linux-pam",
    "pkgconfig(libxcrypt)": "libxcrypt",
    "pkgconfig(libcrypt)": "libxcrypt",
    "pkgconfig(libnsl)": "libnsl",
    "pkgconfig(liblz4)": "lz4",
    "pkgconfig(libevent)": "libevent",
    "pkgconfig(libarchive)": "libarchive",
    "pkgconfig(sqlite3)": "sqlite",
    "pkgconfig(libpq)": "postgresql",
    "pkgconfig(mysqlclient)": "mariadb",
    "pkgconfig(json-c)": "json-c",
    "pkgconfig(json-glib-1.0)": "json-glib",
    "pkgconfig(libunistring)": "libunistring",
    "pkgconfig(libidn2)": "libidn2",
    "pkgconfig(libpsl)": "libpsl",
    "pkgconfig(icu-uc)": "icu",
    "pkgconfig(icu-i18n)": "icu",
    "pkgconfig(icu-io)": "icu",
    "pkgconfig(gnutls)": "gnutls",
    "pkgconfig(nettle)": "nettle",
    "pkgconfig(hogweed)": "nettle",
    "pkgconfig(libgcrypt)": "libgcrypt",
    "pkgconfig(libgpg-error)": "libgpg-error",
    "pkgconfig(libassuan)": "libassuan",
    "pkgconfig(libusb-1.0)": "libusb",
    "pkgconfig(libusb)": "libusb",
    "pkgconfig(libgudev-1.0)": "libgudev",
    "pkgconfig(gudev-1.0)": "libgudev",
    "pkgconfig(polkit-gobject-1)": "polkit",
    "pkgconfig(polkit-agent-1)": "polkit",
    "pkgconfig(libpciaccess)": "libpciaccess",
    "pkgconfig(pixman-1)": "pixman",
    "pkgconfig(libdrm)": "libdrm",
    "pkgconfig(libva)": "libva",
    "pkgconfig(libva-drm)": "libva",
    "pkgconfig(libva-x11)": "libva",
    "pkgconfig(libva-wayland)": "libva",
    "pkgconfig(vdpau)": "libvdpau",
    "pkgconfig(libvdpau)": "libvdpau",
    "pkgconfig(libinput)": "libinput",
    "pkgconfig(libevdev)": "libevdev",
    "pkgconfig(mtdev)": "mtdev",
    # ── grafika / GL / multimedia ──
    "pkgconfig(gbm)": "mesa",
    "pkgconfig(gl)": "libglvnd",
    "pkgconfig(egl)": "libglvnd",
    "pkgconfig(glesv2)": "libglvnd",
    "pkgconfig(glx)": "libglvnd",
    "pkgconfig(vulkan)": "vulkan-loader",
    "pkgconfig(libxkbcommon)": "libxkbcommon",
    "pkgconfig(xkbcommon)": "libxkbcommon",
    "pkgconfig(xkbcommon-x11)": "libxkbcommon",
    "pkgconfig(xcb)": "xorg-libxcb",
    "pkgconfig(xcb-util)": "xcb-util",
    "pkgconfig(xcb-keysyms)": "xcb-util-keysyms",
    "pkgconfig(xcb-icccm)": "xcb-util-wm",
    "pkgconfig(xcb-cursor)": "xcb-util-cursor",
    "pkgconfig(xcb-renderutil)": "xcb-util-renderutil",
    "pkgconfig(xcb-image)": "xcb-util-image",
    "pkgconfig(xcb-errors)": "xcb-util-errors",
    "pkgconfig(wayland-client)": "wayland",
    "pkgconfig(wayland-server)": "wayland",
    "pkgconfig(wayland-cursor)": "wayland",
    "pkgconfig(wayland-egl)": "wayland",
    "pkgconfig(wayland-protocols)": "wayland-protocols",
    "pkgconfig(gstreamer-1.0)": "gstreamer",
    "pkgconfig(gstreamer-base-1.0)": "gstreamer",
    "pkgconfig(gstreamer-check-1.0)": "gstreamer",
    "pkgconfig(gstreamer-controller-1.0)": "gstreamer",
    "pkgconfig(gstreamer-app-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-video-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-audio-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-pbutils-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-fft-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-riff-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-rtp-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-rtsp-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-sdp-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-net-1.0)": "gst-plugins-base",
    "pkgconfig(gstreamer-gl-1.0)": "gst-plugins-base",
    "pkgconfig(libpulse)": "libpulse",
    "pkgconfig(libpulse-simple)": "libpulse",
    "pkgconfig(libpulse-mainloop-glib)": "libpulse",
    "pkgconfig(alsa)": "alsa-lib",
    "pkgconfig(jack)": "jack2",
    "pkgconfig(libsamplerate)": "libsamplerate",
    "pkgconfig(sndfile)": "libsndfile",
    "pkgconfig(libavcodec)": "ffmpeg",
    "pkgconfig(libavformat)": "ffmpeg",
    "pkgconfig(libavutil)": "ffmpeg",
    "pkgconfig(libavfilter)": "ffmpeg",
    "pkgconfig(libswscale)": "ffmpeg",
    "pkgconfig(libswresample)": "ffmpeg",
    "pkgconfig(libpostproc)": "ffmpeg",
    "pkgconfig(SDL2)": "sdl2",
    "pkgconfig(SDL)": "sdl",
    "pkgconfig(SDL2_image)": "sdl2-image",
    "pkgconfig(SDL2_ttf)": "sdl2-ttf",
    "pkgconfig(SDL2_mixer)": "sdl2-mixer",
    "pkgconfig(SDL2_net)": "sdl2-net",
    "pkgconfig(libpng16)": "libpng",
    "pkgconfig(libwebp)": "libwebp",
    "pkgconfig(libwebpmux)": "libwebp",
    "pkgconfig(libwebpdemux)": "libwebp",
    "pkgconfig(libopenjp2)": "openjpeg2",
    "pkgconfig(lcms2)": "lcms2",
    "pkgconfig(libheif)": "libheif",
    "pkgconfig(libde265)": "libde265",
    "pkgconfig(x264)": "x264",
    "pkgconfig(x265)": "x265",
    # ── glib / gio ──
    "pkgconfig(gio-unix-2.0)": "glib",
    "pkgconfig(gmodule-2.0)": "glib",
    "pkgconfig(gthread-2.0)": "glib",
    "pkgconfig(girepository-2.0)": "gobject-introspection",
    "pkgconfig(girepository-1.0)": "gobject-introspection",
    "pkgconfig(libglib-2.0)": "glib",
    "pkgconfig(libgobject-2.0)": "glib",
}

# Ostrzeżenia o wielu dostawcach tej samej wirtualnej nazwy – raz na proces.
_PROVIDES_WARNED = set()
# Cache indeksu provides dla danego obiektu repo: (repo_obj, {virtual: [pkg,...]}).
# Trzymamy referencję do repo, by uniknąć pomyłki przy ponownym użyciu id().
_provides_cache = (None, {})

def _provides_index(repo: dict) -> dict:
    """Buduje (i cache’uje) mapę wirtualna nazwa → lista dostawców w repo.

    Pozwala wybrać dostawcę DETERMINISTYCZNIE (posortowanego) zamiast zależeć
    od kolejności wstawiania w repo.json, oraz ostrzec o konflikcie provides."""
    global _provides_cache
    cached_repo, idx = _provides_cache
    if cached_repo is repo:
        return idx
    idx = {}
    for _pn, _p in repo.items():
        for _prov in (getattr(_p, "provides", None) or []):
            idx.setdefault(_prov, []).append(_pn)
    for _prov, _pns in idx.items():
        if len(_pns) > 1 and _prov not in _PROVIDES_WARNED:
            _PROVIDES_WARNED.add(_prov)
            _sorted = sorted(_pns)
            print(f"  ⚠ {_('provides_conflict', name=_prov, providers=', '.join(_sorted), chosen=_sorted[0])}",
                  file=sys.stderr)
    _provides_cache = (repo, idx)
    return idx


def _resolve_provides(name: str, repo: dict, installed: Optional[dict] = None) -> str:
    """Rozwija wirtualną nazwę pakietu do rzeczywistej nazwy.

    Kolejność: repo → PROVIDES_MAP → wzorce → provides z repo.json →
    provides ZAINSTALOWANYCH pakietów (lokalnie zbudowane poza repo też
    dostarczają wirtualne zależności) → fallback pkgconfig (czyszczenie nazwy).
    """
    if name in repo:
        return name
    if name in PROVIDES_MAP:
        real = PROVIDES_MAP[name]
        if real in repo:
            return real
    # Wzorce: moduły Qt (Qt5Core/Qt6Widgets) i GStreamer (gstreamer-video-1.0)
    if name.startswith("pkgconfig(Qt5"):
        real = "qt5"
        if real in repo:
            return real
    if name.startswith("pkgconfig(Qt6"):
        real = "qt6"
        if real in repo:
            return real
    if name.startswith("pkgconfig(gstreamer-") and name.endswith("-1.0)"):
        real = "gstreamer"
        if real in repo:
            return real
    if name.startswith("pkgconfig(gst-"):
        real = "gst-plugins-base"
        if real in repo:
            return real
    # Dynamiczne provides z repo.json (sekcja provides: w PAGBUILD.yaml)
    # Determinizm: przy wielu dostawcach wybieramy posortowanego pierwszego
    # (i ostrzegamy raz), zamiast zależeć od kolejności w repo.json.
    _idx = _provides_index(repo)
    if name in _idx:
        return min(_idx[name])
    # provides ZAINSTALOWANYCH pakietów – lokalnie zbudowane (pagbuild, poza
    # repo) też dostarczają wirtualne zależności i muszą być rozpoznawane.
    if installed:
        _inst_cands = [pn for pn, meta in installed.items()
                       if isinstance(meta, dict) and name in (meta.get("provides") or [])]
        if _inst_cands:
            return min(_inst_cands)
    clean = name
    if name.startswith("pkgconfig(") and ")" in name:
        clean = name.split("(", 1)[1].rstrip(")")
    elif name.startswith("pkgconfig32(") and ")" in name:
        clean = name.split("(", 1)[1].rstrip(")")
    if clean != name and clean in repo:
        return clean
    return name


def cmd_why(pkg_name: str):
    """Pokazuje dlaczego pakiet jest zainstalowany."""
    installed = load_json(INSTALLED_DB)
    world = load_world()
    if pkg_name not in installed:
        print(f"  {pkg_name}: {_('why_not_installed')}"); return 1
    if pkg_name in world:
        print(f"  {pkg_name}-{installed[pkg_name]['version']}: {_('why_explicit')}")
        return 0
    parents = set()
    for w in world:
        _find_dep_path(w, pkg_name, installed, set(), [], parents)
    if parents:
        for pp in sorted(parents):
            print(f"  {pkg_name}: {_('why_dependency')} {' → '.join(pp)}")
    else:
        print(f"  {pkg_name}: {_('why_dependency')} (unknown/orphan)")
    return 0


def _find_dep_path(cur, target, installed, visited, path, results):
    if cur in visited: return
    visited.add(cur); path.append(cur)
    if cur == target:
        results.add(tuple(path))
    else:
        for dep in installed.get(cur, {}).get("dependencies", []):
            _find_dep_path(dep, target, installed, visited, path, results)
    path.pop(); visited.discard(cur)


def cmd_rdepends(pkg_name: str):
    """Pokazuje które pakiety zależą od danego pakietu (reverse dependencies).

    Odwrotność `pag why`: dla każdego zainstalowanego pakietu sprawdza, czy
    któraś z jego zależności (także wirtualna, przez provides) wskazuje na
    pkg_name. Przydatne przed `pag remove` – pokazuje, co przestanie działać.
    """
    installed = load_json(INSTALLED_DB)
    if pkg_name not in installed:
        print(f"  {pkg_name}: {_('why_not_installed')}"); return 1
    world = load_world()
    # Nazwy, które zależą od pkg_name – sama nazwa plus jej wirtualne provides.
    provided = {pkg_name} | set(installed[pkg_name].get("provides") or [])
    rev = []
    for name, meta in installed.items():
        if name == pkg_name:
            continue
        for dep in (meta.get("dependencies") or []):
            if dep in provided or _resolve_provides(dep, {}, installed) == pkg_name:
                rev.append(name); break
    if not rev:
        print(f"  {pkg_name}: {_('rdepends_none')}")
        return 0
    print(f"🔗 {_('rdepends_title', pkg_name, len(rev))}")
    for n in sorted(rev):
        kind = _("why_explicit") if n in world else _("why_dependency")
        print(f"  {n}-{installed[n].get('version', '?')}  ({kind})")
    return 0


def cmd_autoremove():
    """Automatycznie usuwa osierocone zależności bez pytania."""
    installed = load_json(INSTALLED_DB)
    world = load_world()
    orphans = _find_orphans(installed, world)
    if not orphans: print(f"✅ {_('autoremove_none')}"); return 0
    print(f"🗑 {_('orphans_found', len(orphans), ', '.join(sorted(orphans)[:10]))}")
    return cmd_remove(list(orphans))


def cmd_download(package_names):
    """Pobiera pakiety do cache bez instalowania."""
    ensure_dirs()
    repo = fetch_all_packages()
    if not repo: print(f"❌ {_('no_index')}"); return 1
    total_size = 0; downloaded = []
    for name in package_names:
        pkg = repo.get(name)
        if not pkg:
            print(f"  ❌ {name}: {_('not_found')}"); continue
        print(f"  ↓ {name}-{pkg.version} ...", end=" ", flush=True)
        path = _download_pkg(pkg)
        if path:
            total_size += os.path.getsize(path)
            downloaded.append(name)
            print(_c("green", "✓"))
        else:
            print(_c("red", "✗"))
    if downloaded:
        print(f"\n✅ {_('downloaded', len(downloaded), total_size/1048576)}")
    return 0 if len(downloaded) == len(package_names) else 1


def cmd_stats():
    """Wyświetla statystyki PAG."""
    installed = load_json(INSTALLED_DB)
    history = load_json(HISTORY_FILE) if os.path.exists(HISTORY_FILE) else []
    total_size = sum(i.get("size_bytes", 0) for i in installed.values())
    total_files = _db_count_files()
    cache_size = sum(
        os.path.getsize(os.path.join(PAG_CACHE, f))
        for f in os.listdir(PAG_CACHE)
        if os.path.isfile(os.path.join(PAG_CACHE, f))
    ) if os.path.isdir(PAG_CACHE) else 0
    last_update = _("never")
    for e in reversed(history):
        if e.get("action") in ("install", "upgrade") and e.get("success"):
            last_update = e.get("timestamp", "?")[:19]; break
    print(f"\n  {_c('bold', _('stats_title'))}")
    print(f"  {'─' * 40}")
    print(f"  {_('stats_packages'):<30} {len(installed)}")
    print(f"  {_('stats_files'):<30} {total_files}")
    print(f"  {_('stats_size'):<30} {total_size/1048576:.1f} MB")
    print(f"  {_('stats_cache'):<30} {cache_size/1048576:.1f} MB")
    print(f"  {_('stats_history'):<30} {len(history)}")
    print(f"  {_('stats_last_update'):<30} {last_update}")
    _bs = _base_summary(repo={})   # bez sieci – tylko stan zarządzania bazą
    if _bs["total"]:
        _bt = f"{_bs['tracked']}/{_bs['total']}"
        if _bs["tracked"] < _bs["total"]:
            _bt += "   (sudo pag base adopt)"
        print(f"  {_('stats_base'):<30} {_bt}")
    by_size = sorted(installed.items(), key=lambda x: x[1].get("size_bytes", 0), reverse=True)[:5]
    if by_size:
        print(f"\n  {_c('dim', _('stats_top'))}")
        for n, i in by_size:
            print(f"    {n}-{i['version']}  {i.get('size_bytes',0)/1048576:.1f} MB")
    return 0


def cmd_repo_add(url, name=None):
    if not url.startswith("https://") and not os.environ.get("PAG_INSECURE"):
        print(f"  {_('sec_https')}"); return 1
    ensure_dirs()
    url = url.rstrip("/")
    repos = get_repos()
    if url in repos: print(f"⚠ {_('repo_exists', url)}"); return
    if name:
        # Drop-in: /etc/pag/repos/<nazwa>.conf (jak `echo url > .../stable.conf`)
        os.makedirs(REPOS_DIR, exist_ok=True)
        target = os.path.join(REPOS_DIR, name.rstrip("/").replace("/", "_") + ".conf")
        with open(target, "w") as f: f.write(f"{url}\n")
        print(f"✅ {_('repo_added', url)} → {target}")
        return
    with open(REPOS_CONF, "a") as f: f.write(f"{url}\n")
    print(f"✅ {_('repo_added', url)}")

def cmd_repo_list():
    for i, url in enumerate(get_repos(), 1): print(f"  {i}. {url}")

FLATPAK_REMOTE_URL = "https://flathub.org/repo/flathub.flatpakrepo"

def _check_flatpak(quiet: bool = False):
    if not shutil.which("flatpak"):
        if not quiet:
            print(f"❌ {_('flatpak_missing')}")
        return False
    r = subprocess.run(["flatpak", "remotes"], capture_output=True, text=True)
    if "flathub" not in r.stdout:
        print(f"⚠ {_('flatpak_adding')}")
        # Jako root dodajemy remote systemowy; bez roota – w instalacji użytkownika,
        # żeby remote i miejsce instalacji były spójne (patrz _flatpak_do_install).
        add = ["flatpak", "remote-add", "--if-not-exists"]
        if os.geteuid() != 0:
            add.append("--user")
        subprocess.run(add + ["flathub", FLATPAK_REMOTE_URL], check=False)
    return True

def _spinner(msg: str):
    """Prosty spinner „myślenia” w osobnym wątku. Zwraca funkcję stop()."""
    stop = threading.Event()
    def _spin():
        for c in itertools.cycle("|/-\\"):
            if stop.is_set():
                break
            sys.stdout.write(f"\r  {msg} {c}")
            sys.stdout.flush()
            time.sleep(0.1)
    t = threading.Thread(target=_spin, daemon=True)
    t.start()
    def _stop():
        stop.set()
        t.join(timeout=0.3)
        sys.stdout.write("\r" + " " * (len(msg) + 4) + "\r")
        sys.stdout.flush()
    return _stop


def _flatpak_search_raw(query: str) -> List[dict]:
    """Szuka we Flathub i zwraca listę wyników jako słowniki."""
    if not _check_flatpak():
        return []
    stop = _spinner(_("flatpak_searching_any"))
    try:
        try:
            r = subprocess.run(
                ["flatpak", "search", "--columns=name,description,application,version,branch,remotes", query],
                capture_output=True, text=True, timeout=120
            )
        finally:
            stop()
        if r.returncode != 0 and "No matches found" not in r.stdout and not r.stdout.strip():
            print(f"  ⚠ flatpak search: {r.stderr.strip()[:150]}")
        results = []
        for line in r.stdout.strip().split("\n"):
            parts = line.split("\t")
            if len(parts) >= 3:
                results.append({
                    "name": parts[0].strip(),
                    "description": parts[1].strip() if len(parts) > 1 else "",
                    "app_id": parts[2].strip() if len(parts) > 2 else "",
                    "version": parts[3].strip() if len(parts) > 3 else "",
                    "branch": parts[4].strip() if len(parts) > 4 else "stable",
                    "origin": parts[5].strip() if len(parts) > 5 else "flathub",
                })
        return results
    except Exception as e:
        print(_('  ⚠ Search error: {arg1}', arg1=(e)), file=sys.stderr)
        return []

def _flatpak_find_best(query: str) -> Optional[dict]:
    """
    Szuka we Flathub i próbuje znaleźć najlepsze dopasowanie.
    - Jeśli query dokładnie pasuje do app_id → zwraca od razu
    - Jeśli query pasuje do nazwy → zwraca pierwsze
    - Jeśli wiele wyników → wyświetla listę i pyta użytkownika
    - Jeśli brak → zwraca None
    """
    results = _flatpak_search_raw(query)
    if not results:
        return None

    # Dokładne dopasowanie app_id
    exact = [r for r in results if r["app_id"].lower() == query.lower()]
    if exact:
        return exact[0]

    # Dokładne dopasowanie nazwy
    exact_name = [r for r in results if r["name"].lower() == query.lower()]
    if exact_name:
        return exact_name[0]

    # Jednoznaczne dopasowanie (tylko 1 wynik)
    if len(results) == 1:
        return results[0]

    # Wiele wyników – pokaż użytkownikowi
    print(f"\n  {_('flatpak_found', len(results))}")
    for i, r in enumerate(results):
        print(f"  {i+1}. {_c('bold', r['name'])} ({r['app_id']})")
        if r["version"]:
            print(f"     {_('flatpak_info_version')}: {r['version']}")
        if r["description"]:
            desc = r["description"][:80] + ("..." if len(r["description"]) > 80 else "")
            print(f"     {desc}")

    try:
        choice = input(_('\n  Choose a number (1-{arg1}) or press Enter to cancel:', arg1=(len(results)))).strip()
        if not choice:
            return None
        idx = int(choice) - 1
        if 0 <= idx < len(results):
            return results[idx]
    except (EOFError, ValueError, IndexError):
        pass
    return None

def _flatpak_get_installed_info(app_id: str) -> Optional[dict]:
    """Zwraca info o zainstalowanym flatpaku lub None."""
    try:
        r = subprocess.run(
            ["flatpak", "info", "--columns=name,version,branch,origin,installed-size,description", app_id],
            capture_output=True, text=True, timeout=10
        )
        if r.returncode != 0:
            return None
        parts = r.stdout.strip().split("\t")
        if len(parts) < 3:
            return None
        return {
            "name": parts[0].strip(),
            "version": parts[1].strip() if len(parts) > 1 else "",
            "branch": parts[2].strip() if len(parts) > 2 else "",
            "origin": parts[3].strip() if len(parts) > 3 else "",
            "size": parts[4].strip() if len(parts) > 4 else "",
            "description": parts[5].strip() if len(parts) > 5 else "",
        }
    except Exception:
        return None

def _flatpak_is_installed(app_id: str) -> bool:
    """Sprawdza czy flatpak o danym ID jest zainstalowany."""
    try:
        r = subprocess.run(
            ["flatpak", "info", app_id],
            capture_output=True, text=True, timeout=10
        )
        return r.returncode == 0
    except Exception:
        return False

# =============================================================================
# FLATPAK – KOMENDY GŁÓWNE (zunifikowany interfejs)
# =============================================================================
# pag flatpak <query>          → szuka i proponuje instalację (jeśli nie zainstalowany)
# pag flatpak search <query>   → tylko szuka
# pag flatpak install <query>  → instaluje
# pag flatpak remove <id>      → usuwa
# pag flatpak list             → lista zainstalowanych
# pag flatpak update           → aktualizuje wszystkie
# pag flatpak info <id>        → szczegóły flatpaka

def cmd_flatpak(args: list):
    """
    Główna komenda flatpak – inteligentnie rozpoznaje intencję:
      pag flatpak firefox         → szuka i instaluje (jeśli nieznaleziony → szuka)
      pag flatpak search firefox  → tylko wyszukiwanie
      pag flatpak install ...     → bezpośrednia instalacja
      pag flatpak remove ...      → odinstalowanie
      pag flatpak list            → lista
      pag flatpak update          → aktualizacja
      pag flatpak info ...        → szczegóły
    """
    if not _check_flatpak():
        return 1

    if not args:
        # Bez argumentów – domyślnie lista
        return cmd_flatpak_list()

    subcmd = args[0].lower()
    rest = args[1:]

    # ── Podkomendy jawne ────────────────────────────────────────────────
    if subcmd == "search":
        if not rest:
            print(_("flatpak_usage")); return 1
        return cmd_flatpak_search(" ".join(rest))

    elif subcmd == "install":
        if not rest:
            print(_("flatpak_usage")); return 1
        return _flatpak_smart_install(rest)

    elif subcmd == "remove" or subcmd == "uninstall":
        if not rest:
            print(_("flatpak_usage")); return 1
        return _flatpak_smart_remove(rest)

    elif subcmd == "list":
        return cmd_flatpak_list()

    elif subcmd == "update":
        return cmd_flatpak_update()

    elif subcmd == "info":
        if not rest:
            print(_("flatpak_usage")); return 1
        return cmd_flatpak_info(rest[0])

    else:
        # ── Inteligentne wykrywanie: pag flatpak <nazwa> ────────────────
        # Sprawdź czy to zainstalowany flatpak → pokaż info
        # Jeśli nie → szukaj i zaproponuj instalację
        query = " ".join(args)

        # Najpierw sprawdź czy już zainstalowany
        if _flatpak_is_installed(query):
            print(_("  📦 {arg1} – already installed (use 'pag flatpak info {arg2}' for details)", arg1=(_c('green', query)), arg2=(query)))
            return cmd_flatpak_info(query)

        # Szukaj we Flathub
        print(f"  {_('flatpak_searching', query)}")
        best = _flatpak_find_best(query)
        if not best:
            print(f"  ❌ '{query}' – {_('flatpak_not_found')}")
            return 1

        print(f"\n  {_c('cyan', best['name'])} ({best['app_id']})")
        if best["version"]:
            print(f"  {_('flatpak_info_version')}: {best['version']}")
        if best["description"]:
            print(f"  {best['description']}")

        try:
            ans = input(f"\n  {_('flatpak_install_prompt', best['name'])}").strip().lower()
        except (EOFError, KeyboardInterrupt):
            print(f"\n  ⚠ {_('no_tty')}")
            return 0
        if ans and ans not in ("t", "y"):
            print(_("cancelled"))
            return 0

        return _flatpak_do_install(best["app_id"])

def _flatpak_smart_install(names: list) -> int:
    """Instaluje flatpaki – obsługuje nazwy częściowe (wyszukuje przed instalacją)."""
    failed = 0
    for name in names:
        if "." in name and "/" not in name:
            # Wygląda na pełne app_id (np. org.mozilla.firefox)
            app_id = name
        else:
            # Szukaj najlepszego dopasowania
            best = _flatpak_find_best(name)
            if not best:
                print(f"  ❌ '{name}' – {_('flatpak_not_found')}")
                failed += 1
                continue
            app_id = best["app_id"]
            print(f"  → {best['name']} ({app_id})")

        if _flatpak_do_install(app_id) != 0:
            failed += 1
    return 1 if failed else 0

def _flatpak_export_dirs() -> List[str]:
    """Katalogi eksportów Flatpaka (system + użytkownika) obecne na dysku.

    Instalacja użytkownika roota (/root/.local/share/flatpak) jest świadomie
    POMIJANA – to wewnętrzny artefakt roota, którego sesja użytkownika nigdy
    nie zobaczy (patrz _flatpak_do_install)."""
    dirs = ["/var/lib/flatpak/exports"]
    home = os.path.expanduser("~")
    if home and home not in ("/root", "/"):
        dirs.append(os.path.join(home, ".local", "share", "flatpak", "exports"))
    return [d for d in dirs if os.path.isdir(d)]


def _flatpak_refresh_caches() -> None:
    """Odświeża cache pulpitu i ikon po zmianie w Flatpaku (best-effort).

    Flatpak robi to sam, ale tylko gdy `update-desktop-database` jest w PATH.
    Bez tego nowo zainstalowana aplikacja bywa nieobecna w menu."""
    for exports in _flatpak_export_dirs():
        apps = os.path.join(exports, "share", "applications")
        if os.path.isdir(apps) and shutil.which("update-desktop-database"):
            subprocess.run(["update-desktop-database", apps],
                           capture_output=True, check=False, timeout=60)
        icons = os.path.join(exports, "share", "icons", "hicolor")
        if os.path.isdir(icons) and shutil.which("gtk-update-icon-cache"):
            subprocess.run(["gtk-update-icon-cache", "-q", "-t", "-f", icons],
                           capture_output=True, check=False, timeout=120)


def _flatpak_session_sees_exports() -> bool:
    """Czy bieżąca sesja ma eksporty Flatpaka w XDG_DATA_DIRS."""
    raw = os.environ.get("XDG_DATA_DIRS", "")
    dirs = {d for d in raw.split(":") if d} or {"/usr/local/share", "/usr/share"}
    return any(os.path.join(e, "share") in dirs for e in _flatpak_export_dirs())


def _flatpak_warn_if_invisible() -> None:
    """Ostrzega, gdy sesja nie widzi eksportów – inaczej wygląda to jak
    „zainstalowało się, ale nie ma go w menu / na PC”."""
    if not _flatpak_session_sees_exports():
        print(f"  ⚠ {_('flatpak_menu_hint')}")
        print(f"     {_('flatpak_menu_fix')}")


def _flatpak_do_install(app_id: str) -> int:
    """Wykonuje właściwą instalację flatpaka.

    Jako root wymuszamy instalację SYSTEMOWĄ (--system). Bez tego `flatpak`
    uruchomiony jako root potrafi zainstalować aplikację w instalacji
    użytkownika roota (/root/.local/share/flatpak) – widocznej dla roota, ale
    nie dla zalogowanego użytkownika. To dokładnie efekt „instaluje, ale nie
    mam tego na PC”. Bez roota próbujemy instalacji systemowej (polkit),
    a w razie niepowodzenia cofamy się do instalacji użytkownika (--user).

    Zakres (scope) ma znaczenie: instalacja SYSTEMOWA (--system) jest widoczna
    dla wszystkich użytkowników, a --user tylko dla bieżącego (dla roota:
    /root/.local/... → niewidoczna dla sesji). `flatpak list` bez flag pokazuje
    oba zakresy, więc systemowa instalacja roota jest widoczna też dla
    zwykłego użytkownika."""
    print(f"  {_('flatpak_installing', app_id)}")
    if os.geteuid() == 0:
        result = subprocess.run(
            ["flatpak", "install", "-y", "--system", "flathub", app_id],
            check=False, timeout=600)
    else:
        result = subprocess.run(
            ["flatpak", "install", "-y", "flathub", app_id],
            check=False, timeout=600)
        if result.returncode != 0:
            # Flathub tylko dla użytkownika / brak agenta polkit – instalacja
            # lokalna użytkownika jest lepsza niż twardy błąd.
            subprocess.run(
                ["flatpak", "remote-add", "--if-not-exists", "--user",
                 "flathub", FLATPAK_REMOTE_URL], check=False, timeout=60)
            result = subprocess.run(
                ["flatpak", "install", "-y", "--user", "flathub", app_id],
                check=False, timeout=600)
    if result.returncode != 0:
        print(f"  ❌ {_('download_fail')}: {app_id}")
        return 1
    _flatpak_refresh_caches()
    print(f"  ✅ {_('flatpak_installed', app_id)}")
    _flatpak_warn_if_invisible()
    return 0

def _flatpak_smart_remove(names: list) -> int:
    """Usuwa flatpaki – obsługuje nazwy częściowe."""
    # Pobierz listę zainstalowanych
    try:
        r = subprocess.run(
            ["flatpak", "list", "--columns=application,name"],
            capture_output=True, text=True, timeout=10
        )
        installed = {}
        for line in r.stdout.strip().split("\n"):
            parts = line.split("\t")
            if len(parts) >= 2:
                installed[parts[0].strip()] = parts[1].strip()
    except Exception:
        installed = {}

    failed = 0
    for name in names:
        app_id = name

        # Jeśli nie podano pełnego ID – spróbuj dopasować
        if name not in installed:
            matches = {aid: aname for aid, aname in installed.items()
                       if name.lower() in aid.lower() or name.lower() in aname.lower()}
            if len(matches) == 0:
                print(f"  ❌ '{name}' – {_('flatpak_not_installed', name)}")
                failed += 1
                continue
            elif len(matches) == 1:
                app_id = list(matches.keys())[0]
                print(f"  → {matches[app_id]} ({app_id})")
            else:
                print(_("\n  Multiple matches for '{arg1}':", arg1=(name)))
                for i, (aid, aname) in enumerate(sorted(matches.items()), 1):
                    print(f"  {i}. {aname} ({aid})")
                try:
                    choice = input(_('\n  Choose a number (1-{arg1}) or press Enter:', arg1=(len(matches)))).strip()
                    if not choice:
                        failed += 1
                        continue
                    aid_list = sorted(matches.keys())
                    app_id = aid_list[int(choice) - 1]
                except (EOFError, ValueError, IndexError):
                    failed += 1
                    continue

        print(f"  🗑 {app_id} ...", end=" ", flush=True)
        result = subprocess.run(
            ["flatpak", "uninstall", "-y", app_id],
            capture_output=True, text=True, timeout=120
        )
        if result.returncode == 0:
            print("✅")
            print(f"  {_('flatpak_removed', app_id)}")
        else:
            print("❌")
            failed += 1
    if not failed:
        _flatpak_refresh_caches()
    return 1 if failed else 0

def cmd_flatpak_search(q: str):
    """Wyszukuje we Flathub i wyświetla wyniki (z możliwością wyboru do instalacji)."""
    if not _check_flatpak():
        return 1
    results = _flatpak_search_raw(q)
    if not results:
        print(f"  ❌ '{q}' – {_('flatpak_not_found')}")
        return 1
    print(f"\n  {_('flatpak_found', len(results))}")
    shown = results[:30]  # max 30 wyników
    for i, r in enumerate(shown, 1):
        installed = "📦 " if _flatpak_is_installed(r["app_id"]) else "   "
        print(f"  {i:>2}. {installed}{_c('bold', r['name'])} ({r['app_id']})")
        if r["version"]:
            print(f"      {_('flatpak_info_version')}: {r['version']}  |  {_('flatpak_info_branch')}: {r['branch']}")
        if r["description"]:
            desc = r["description"][:100] + ("..." if len(r["description"]) > 100 else "")
            print(f"      {_c('dim', desc)}")
    if len(results) > 30:
        print(_('  ... and {arg1} more. Refine your query.', arg1=(len(results) - 30)))

    # Interaktywny wybór – wpisz numer, aby zainstalować (Enter = anuluj)
    try:
        ans = input(_('\n  Choose a number to install (1-{arg1}) or press Enter to cancel:', arg1=(len(shown)))).strip()
    except (EOFError, KeyboardInterrupt):
        return 0
    if ans:
        try:
            idx = int(ans) - 1
            if 0 <= idx < len(shown):
                return _flatpak_do_install(shown[idx]["app_id"])
            print(_("cancelled"))
        except (ValueError, IndexError):
            print(_("cancelled"))
    return 0

def cmd_flatpak_list():
    """Wyświetla zainstalowane flatpaki."""
    if not _check_flatpak():
        return 1
    r = subprocess.run(
        ["flatpak", "list", "--columns=application,name,version,origin,installation,installed-size"],
        capture_output=True, text=True, timeout=10
    )
    lines = [l for l in r.stdout.strip().split("\n") if l.strip()]
    if not lines:
        print(_('  (no installed flatpaks)'))
        return 0
    print(_('Installed flatpaks ({arg1}):', arg1=(len(lines))))
    for line in lines:
        parts = line.split("\t")
        if len(parts) >= 3:
            app_id, name, version = parts[0], parts[1], parts[2]
            scope = parts[4] if len(parts) > 4 else ""
            size = parts[5] if len(parts) > 5 else ""
            size_str = f"  ({size})" if size else ""
            scope_str = f" [{scope}]" if scope else ""
            print(f"  📦 {_c('bold', name)} {version}{scope_str}{size_str}")
            print(f"     {_c('dim', app_id)}")
    return 0

def _flatpak_auto_update() -> int:
    """Aktualizuje flatpaki SYSTEMOWE po `pag update`/`pag upgrade`.

    Best-effort i po cichu, gdy nie ma czego robić:
      * brak `flatpak` w PATH → pomiń,
      * brak zainstalowanych aplikacji → pomiń (żadnego ruchu sieciowego),
      * `--no-flatpak` / PAG_FLATPAK=0 → pomiń,
      * NIE dodaje Flathuba (inaczej niż `_check_flatpak`).

    Aktualizuje instalację systemową (root). Instalacje `--user` należą do
    użytkownika – te aktualizuje `pag flatpak update` uruchomiony bez sudo.
    """
    if os.environ.get("PAG_FLATPAK", "") in ("0", "no", "false", "never"):
        return 0
    if not shutil.which("flatpak"):
        return 0
    try:
        lst = subprocess.run(
            ["flatpak", "list", "--app", "--columns=application"],
            capture_output=True, text=True, timeout=60,
        )
    except Exception:
        return 0
    if lst.returncode != 0 or not lst.stdout.strip():
        return 0
    print(_('  🔄 Updating flatpaks...'))
    try:
        res = subprocess.run(["flatpak", "update", "-y"], check=False, timeout=1800)
    except Exception:
        print(f"  ⚠ {_('flatpak_update_failed')}")
        return 1
    if res.returncode == 0:
        _flatpak_refresh_caches()
        print(f"  ✅ {_('flatpak_updated')}")
    else:
        print(f"  ⚠ {_('flatpak_update_failed')}")
    return res.returncode

def cmd_flatpak_update():
    """Aktualizuje wszystkie flatpaki."""
    if not _check_flatpak():
        return 1
    print(_('  🔄 Updating flatpaks...'))
    result = subprocess.run(["flatpak", "update", "-y"], check=False, timeout=600)
    if result.returncode == 0:
        _flatpak_refresh_caches()
        print(f"  ✅ {_('flatpak_updated')}")
    return result.returncode

def cmd_flatpak_info(app_id: str):
    """Wyświetla szczegóły flatpaka (zainstalowanego lub z Flathub)."""
    if not _check_flatpak():
        return 1

    # Najpierw sprawdź zainstalowany
    info = _flatpak_get_installed_info(app_id)
    if info:
        print(f"\n  📦 {_c('bold', info['name'])} {_c('green', '[zainstalowany]')}")
        print(f"  {'─' * 45}")
        print(f"  {_('flatpak_info_id'):<16} {app_id}")
        print(f"  {_('flatpak_info_version'):<16} {info['version']}")
        print(f"  {_('flatpak_info_branch'):<16} {info['branch']}")
        print(f"  {_('flatpak_info_origin'):<16} {info['origin']}")
        if info["size"]:
            print(f"  {_('flatpak_info_size'):<16} {info['size']}")
        if info["description"]:
            print(f"  {_('flatpak_info_desc'):<16} {info['description']}")
        return 0

    # Szukaj we Flathub
    results = _flatpak_search_raw(app_id)
    exact = [r for r in results if r["app_id"].lower() == app_id.lower()]
    if not exact:
        # Spróbuj częściowego dopasowania
        if results:
            exact = [results[0]]
        else:
            print(f"  ❌ '{app_id}' – {_('flatpak_not_found')}")
            return 1

    r = exact[0]
    print(f"\n  📦 {_c('bold', r['name'])} (Flathub)")
    print(f"  {'─' * 45}")
    print(f"  {_('flatpak_info_id'):<16} {r['app_id']}")
    print(f"  {_('flatpak_info_version'):<16} {r['version']}")
    if r["description"]:
        print(f"  {_('flatpak_info_desc'):<16} {r['description']}")
    print(_('\n  💡 To install: pag flatpak install {arg1}', arg1=(r['app_id'])))
    return 0

# =============================================================================
# IMMUTABLE OS – KOMENDY DEPLOYMENTOWE
# =============================================================================

# Pakiety jądra – po ich instalacji trzeba przebudować initramfs
KERNEL_PACKAGE_PATTERNS = ["linux", "kernel", "linux-kernel", "linux-lts"]

# Pakiety, po których initramfs MUSI zostać przebudowany: jądra oraz moduły
# out-of-tree (NVIDIA/VirtualBox). `pag` robi to raz, po całej transakcji.
INITRAMFS_PACKAGE_PATTERNS = tuple(KERNEL_PACKAGE_PATTERNS) + (
    "nvidia-dkms", "nvidia-kernel",
    "vboxhost-kernel", "virtualbox-host-modules", "virtualbox-guest-modules",
)

def _is_kernel_package(name: str) -> bool:
    """Sprawdza czy pakiet to jądro (wymaga przebudowy initramfs)."""
    name_lower = name.lower()
    return any(pattern in name_lower for pattern in KERNEL_PACKAGE_PATTERNS)


def _needs_initramfs_refresh(name: str) -> bool:
    """Czy po tym pakiecie trzeba przebudować initramfs (jądro lub moduły)."""
    name_lower = name.lower()
    return any(pattern in name_lower
               for pattern in INITRAMFS_PACKAGE_PATTERNS)

# Towarzysze jądra – aktualizowani RAZEM z jądrem, jeśli są zainstalowani,
# żeby userspace i moduły jądra nie rozjechały się wersjami.
KERNEL_SIBLINGS = ("linux-headers", "nvidia-dkms", "nvidia-kernel", "dkms",
                   "virtualbox-host-modules", "virtualbox-guest-modules")


def _kernel_group_updates(pending):
    """Gdy w transakcji jest jądro, dołóż jego towarzyszy (jeśli zainstalowani)."""
    if not any(_is_kernel_package(n) for n in pending):
        return pending
    try:
        installed = load_json(INSTALLED_DB)
        repo = fetch_all_packages()
    except Exception:
        return pending
    out = list(pending)
    for sib in KERNEL_SIBLINGS:
        if sib in installed and sib in repo and sib not in out:
            out.append(sib)
    return out


def _post_kernel_hooks():
    """Po zmianie jądra na ZWYKŁEJ instalacji: DKMS → depmod → initramfs → GRUB.

    Kolejność ma znaczenie: najpierw moduły out-of-tree (DKMS) pod nowe jądro,
    potem depmod (żeby modules.dep zawierał też nvidia/vbox – pakiety jądra
    potrafią dostarczyć własny, niepełny modules.dep), potem initramfs (żeby
    zawierał już przebudowane moduły), na końcu wpisy GRUB. To JEDYNE miejsce,
    które finalizuje jądro po transakcji.
    """
    if shutil.which("dkms"):
        try:
            print(_('  🔧 DKMS: rebuilding out-of-tree modules (nvidia/vbox)...'))
            subprocess.run(["dkms", "autoinstall"],
                           capture_output=True, text=True, timeout=1800)
        except Exception:
            pass
    _refresh_depmod()
    try:
        _rebuild_initramfs()
    except Exception:
        pass
    _refresh_bootloader()


def _refresh_depmod(root: str = "") -> None:
    """Przelicz `modules.dep` dla wszystkich jąder w `<root>/usr/lib/modules`.

    Niektóre pakiety jądra dostarczają własny modules.dep wygenerowany w chwili
    budowy – bez modułów doinstalowanych później (np. nvidia-kernel). Po
    reinstalacji jądra taki plik nadpisuje poprawny indeks i `modprobe`
    przestaje widzieć nvidia*.ko, mimo że pliki są na dysku. Depmod po całej
    transakcji naprawia to również dla kolejnych bootów.
    """
    depmod = shutil.which("depmod") or "/usr/sbin/depmod"
    if not os.path.exists(depmod):
        return
    base = os.path.join(root or PAG_ROOT, "usr/lib/modules")
    try:
        versions = sorted(os.listdir(base))
    except OSError:
        return
    print(_('  🔧 Refreshing module dependencies (depmod)...'))
    for ver in versions:
        if not os.path.isdir(os.path.join(base, ver)):
            continue
        cmd = [depmod, "-a"]
        if root:
            cmd += ["-b", root]
        cmd.append(ver)
        try:
            subprocess.run(cmd, capture_output=True, text=True, timeout=120)
        except Exception:
            pass

def _rebuild_initramfs(deploy_dir: str = "") -> bool:
    """
    Przebudowuje initramfs dla aktywnego (lub podanego) deploymentu.
    Używa skryptu pag-initramfs lub ręcznego cpio.
    """
    if deploy_dir:
        root = deploy_dir
    else:
        root = _get_deployment_root()

    if root == PAG_ROOT:
        # Zwykły system – NAJPIERW natywne narzędzie PaganOS (per-wersja +
        # root=UUID/PARTUUID/LABEL), potem dracut/mkinitcpio.
        if shutil.which("pagan-initramfs"):
            print(_('  🔧 Rebuilding initramfs (pagan-initramfs)...'))
            try:
                r = subprocess.run(["pagan-initramfs"], capture_output=True,
                                   text=True, timeout=1800)
                if r.returncode == 0:
                    return True
            except Exception:
                pass
        # Zwykły system – użyj dracut jeśli dostępny
        if shutil.which("dracut"):
            print(_('  🔧 Rebuilding initramfs (dracut)...'))
            result = subprocess.run(
                ["dracut", "--force", "/boot/initramfs.img"],
                capture_output=True, text=True, timeout=600
            )
            return result.returncode == 0
        elif shutil.which("mkinitcpio"):
            print(_('  🔧 Rebuilding initramfs (mkinitcpio)...'))
            result = subprocess.run(
                ["mkinitcpio", "-g", "/boot/initramfs.img"],
                capture_output=True, text=True, timeout=600
            )
            return result.returncode == 0
        else:
            print(_('  ⚠ No dracut/mkinitcpio – initramfs was not rebuilt'))
            return False

    # Tryb immutable – budujemy initramfs dla deploymentu
    print(_('  🔧 Building initramfs for the deployment...'))

    # Sprawdź czy mamy nasz skrypt init
    pag_init_script = "/usr/share/pag/initramfs-init"
    if not os.path.exists(pag_init_script):
        # Szukaj w źródłach (developerski fallback)
        alt_paths = [
            os.path.join(os.path.dirname(os.path.abspath(__file__)), "scripts", "initramfs-init"),
            "/usr/share/pag/init",
        ]
        for p in alt_paths:
            if os.path.exists(p):
                pag_init_script = p
                break

    if not os.path.exists(pag_init_script):
        print(_('  ⚠ pag-initramfs-init not found – skipping initramfs build'))
        return False

    boot_dir = os.path.join(root, "boot")
    os.makedirs(boot_dir, exist_ok=True)

    # Znajdź jądro (vmlinuz-*)
    kernels = sorted(
        [f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
        reverse=True
    ) if os.path.exists(boot_dir) else []
    if not kernels:
        print(_("  ⚠ No vmlinuz-* found in the deployment's /boot"))
        return False

    kernel_ver = kernels[0].replace("vmlinuz-", "")
    print(_('  🐧 Kernel: {arg1}', arg1=(kernel_ver)))

    # Buduj initramfs ręcznie (cpio)
    tmpdir = tempfile.mkdtemp(prefix="pag-initramfs-")
    try:
        # Podstawowa struktura
        for d in ["bin", "sbin", "dev", "proc", "sys", "run", "new_root",
                   "usr/bin", "usr/sbin", "lib", "lib64", "etc"]:
            os.makedirs(os.path.join(tmpdir, d), exist_ok=True)

        # Skopiuj init
        shutil.copy2(pag_init_script, os.path.join(tmpdir, "init"))
        os.chmod(os.path.join(tmpdir, "init"), 0o755)

        # Skopiuj niezbędne binaria (busybox lub podstawowe narzędzia)
        busybox_paths = [
            os.path.join(root, "usr/bin/busybox"),
            os.path.join(root, "bin/busybox"),
            "/usr/bin/busybox",
            "/bin/busybox",
        ]
        busybox = None
        for bp in busybox_paths:
            if os.path.exists(bp):
                busybox = bp
                break

        if busybox:
            shutil.copy2(busybox, os.path.join(tmpdir, "bin/busybox"))
            # Utwórz symlinki dla podstawowych komend
            for cmd in ["sh", "mount", "umount", "ls", "cat", "echo", "sleep",
                         "readlink", "mkdir", "switch_root", "cp", "rm"]:
                link = os.path.join(tmpdir, "bin", cmd)
                if not os.path.exists(link):
                    os.symlink("busybox", link)
            # /bin/sh → busybox
            if not os.path.exists(os.path.join(tmpdir, "bin/sh")):
                os.symlink("busybox", os.path.join(tmpdir, "bin/sh"))
        else:
            # Bez busybox – kopiuj podstawowe narzędzia z deploymentu
            for tool in ["bash", "mount", "umount", "readlink", "mkdir", "cat", "sleep", "cp", "rm"]:
                src = os.path.join(root, "usr/bin", tool)
                if not os.path.exists(src):
                    src = os.path.join(root, "bin", tool)
                if os.path.exists(src):
                    dest = os.path.join(tmpdir, "bin", os.path.basename(tool))
                    shutil.copy2(src, dest)
                    # Kopiuj zależności .so
                    _copy_libs_for_binary(src, tmpdir, root)

        # Dodaj moduły jądra (opcjonalnie – dla sterowników dyskowych)
        modules_src = os.path.join(root, "lib/modules", kernel_ver)
        if os.path.isdir(modules_src):
            modules_dst = os.path.join(tmpdir, "lib/modules", kernel_ver)
            # Kopiuj tylko niezbędne (fs, block, drivers/ata, drivers/nvme)
            for sub in ["kernel/fs", "kernel/drivers/ata", "kernel/drivers/nvme",
                         "kernel/drivers/scsi", "kernel/drivers/virtio",
                         "modules.order", "modules.builtin"]:
                src_sub = os.path.join(modules_src, sub)
                if os.path.exists(src_sub):
                    dst_sub = os.path.join(modules_dst, sub)
                    os.makedirs(os.path.dirname(dst_sub), exist_ok=True)
                    if os.path.isdir(src_sub):
                        try:
                            shutil.copytree(src_sub, dst_sub, dirs_exist_ok=True, symlinks=True,
                                            ignore_dangling_symlinks=True)
                        except (FileNotFoundError, PermissionError):
                            print(_('  ⚠ Skipping unavailable files: {arg1}', arg1=(sub)))
                    else:
                        try:
                            shutil.copy2(src_sub, dst_sub)
                        except (FileNotFoundError, PermissionError):
                            print(_('  ⚠ Skipping unavailable file: {arg1}', arg1=(sub)))

        # Pakuj do initramfs.img
        initramfs_path = os.path.join(boot_dir, "initramfs.img")
        old_cwd = os.getcwd()
        os.chdir(tmpdir)
        try:
            with open(initramfs_path + ".tmp", "wb") as out:
                _run_cpio_pipeline(tmpdir, out)
            os.rename(initramfs_path + ".tmp", initramfs_path)
        finally:
            os.chdir(old_cwd)

        size_mb = os.path.getsize(initramfs_path) / 1048576
        print(_('  ✅ initramfs.img ({arg1:.1f} MB) → {arg2}', arg1=(size_mb), arg2=(initramfs_path)))
        return True

    except Exception as e:
        print(_('  ❌ initramfs build error: {arg1}', arg1=(e)))
        return False
    finally:
        shutil.rmtree(tmpdir, ignore_errors=True)


def _run_cpio_pipeline(tmpdir: str, out):
    """find . -print0 | cpio --null -oH newc | gzip — bez shell=True.

    Buduje pipeline przez subprocess.Popen, unikając pośrednika powłoki
    (brak ryzyka injection i niepotrzebnego procesu sh). Wykonuje się w cwd=tmpdir.
    Separatory NUL (\0): plik/katalog ze znakiem nowej linii w nazwie nie
    rozjeżdża cpio (inaczej uszkodzone archiwum → kernel panic przy rozruchu).
    """
    find = subprocess.Popen(["find", ".", "-print0"], cwd=tmpdir, stdout=subprocess.PIPE)
    cpio = subprocess.Popen(["cpio", "--null", "-oH", "newc"], cwd=tmpdir,
                            stdin=find.stdout, stdout=subprocess.PIPE)
    find.stdout.close()  # zwolnij uchwyt – cpio dostanie SIGPIPE po zakończeniu find
    gzip = subprocess.Popen(["gzip"], stdin=cpio.stdout, stdout=out)
    cpio.stdout.close()
    try:
        gzip.wait(timeout=120)
        if gzip.returncode != 0:
            raise subprocess.CalledProcessError(gzip.returncode, ["gzip"])
        cpio.wait(timeout=30)
        find.wait(timeout=30)
    except subprocess.TimeoutExpired:
        for p in (gzip, cpio, find):
            p.kill()
        raise
    finally:
        for p in (find, cpio, gzip):
            if p.poll() is None:
                p.kill()
    # Skontroluj też kody procesów pośrednich (cpio/find mogą zawieść, a gzip zwrócić 0)
    if cpio.returncode != 0:
        raise subprocess.CalledProcessError(cpio.returncode, ["cpio"])
    if find.returncode != 0:
        raise subprocess.CalledProcessError(find.returncode, ["find"])


def _copy_libs_for_binary(binary: str, dest_dir: str, root: str):
    """Kopiuje zależności .so dla binarki do initramfs (uproszczone ldd)."""
    try:
        result = subprocess.run(
            ["ldd", binary], capture_output=True, text=True, timeout=10
        )
        for line in result.stdout.split("\n"):
            m = re.search(r'=>\s+(/\S+)', line)
            if m:
                lib_path = m.group(1)
                lib_rel = lib_path.lstrip("/")
                lib_dest = os.path.join(dest_dir, lib_rel)
                if not os.path.exists(lib_dest):
                    os.makedirs(os.path.dirname(lib_dest), exist_ok=True)
                    # Szukaj w deployment root lub systemie
                    if os.path.exists(lib_path):
                        shutil.copy2(lib_path, lib_dest)
                    else:
                        alt = os.path.join(root, lib_rel)
                        if os.path.exists(alt):
                            shutil.copy2(alt, lib_dest)
    except Exception:
        pass


def cmd_initramfs_update():
    """Ręcznie przebudowuje initramfs dla bieżącego deploymentu."""
    ensure_dirs()
    deploy_dir = _get_deployment_root()
    if deploy_dir != PAG_ROOT:
        print(_('🏗️  Deployment: {arg1}', arg1=(os.path.basename(deploy_dir))))
    ok = _rebuild_initramfs(deploy_dir)
    if ok:
        print(_('✅ Initramfs updated.'))
        # Po initramfs – zaktualizuj też GRUB
        _update_grub_config()
    else:
        print(_('❌ Initramfs update failed.'))
    return 0 if ok else 1


def _boot_prefix() -> str:
    """Prefiks ścieżek jądra/initrd w grub.cfg.

    Gdy /boot jest OSOBNYM punktem montowania, GRUB ma w `root` partycję
    /boot (tam leży grub.cfg i jądra), więc ścieżki podajemy względem niej:
    "/vmlinuz-…", "/initramfs.img" – BEZ przedrostka /boot. Gdy /boot leży
    na roocie, wymagane jest "/boot/…". Zły przedrostek = "file not found".
    """
    try:
        if os.path.isdir("/boot") and os.path.ismount("/boot"):
            return ""
    except OSError:
        pass
    return "/boot"


def _strip_crlf(path: str) -> bool:
    """Usuwa CRLF/CR z pliku. True, jeśli coś zmieniono.

    /etc/default/grub z końcówkami Windows wywala `grub-mkconfig`
    (line 2: bad command), a wtedy menu GRUB nie jest odświeżane po
    aktualizacji jądra — zostaje stary wpis startowy.
    """
    try:
        if not os.path.isfile(path):
            return False
        with open(path, "rb") as f:
            data = f.read()
        if b"\r" not in data:
            return False
        with open(path, "wb") as f:
            f.write(data.replace(b"\r\n", b"\n").replace(b"\r", b"\n"))
        return True
    except Exception:
        return False


def _repair_initramfs_links(boot: str = "/boot") -> bool:
    """Doprowadza aliasy initramfs do stanu, w którym GRUB ma co podać.

    /etc/grub.d/10_linux dodaje linię `initrd` tylko jeśli istnieje
    `initrd.img-<wersja>` lub `initramfs-<wersja>.img`. Dla wpisu z aliasu
    `vmlinuz-linux` szuka `initrd.img-linux` / `initramfs-linux.img`.
    Martwy łańcuch dowiązań = start BEZ initramfs, czyli panika
    (VFS: Cannot open root device), gdy NVMe/LUKS są modułami.
    """
    changed = False
    try:
        if not os.path.isdir(boot):
            return False
        imgs = []
        for n in os.listdir(boot):
            if not (n.startswith("initramfs-") and n.endswith(".img")):
                continue
            ver = n[len("initramfs-"):-len(".img")]
            if not ver or not ver[0].isdigit():
                continue                      # initramfs-linux.img to alias
            fp = os.path.join(boot, n)
            if os.path.isfile(fp) and not os.path.islink(fp):
                imgs.append((os.path.getmtime(fp), n))
        if not imgs:
            return False
        newest = max(imgs)[1]

        def _link(alias: str, target: str, force: bool = False) -> None:
            nonlocal changed
            ap = os.path.join(boot, alias)
            if os.path.islink(ap):
                if os.readlink(ap) == target and os.path.exists(ap):
                    return
                if os.path.exists(ap) and not force:
                    return                    # cel istnieje – nie ruszamy
                os.remove(ap)
            elif os.path.exists(ap):
                return                        # prawdziwy plik – nie ruszamy
            try:
                os.symlink(target, ap)
                changed = True
            except OSError:
                pass

        _link("initramfs.img", newest, force=True)
        if os.path.exists(os.path.join(boot, "vmlinuz-linux")):
            _link("initramfs-linux.img", "initramfs.img")
            _link("initrd.img-linux", "initramfs.img")
        return changed
    except Exception:
        return changed


def _grub_entry_lacks_initrd(grub_cfg: str = "/boot/grub/grub.cfg") -> bool:
    """Czy pierwszy wpis menu nie ma linii `initrd` (start bez initramfs)."""
    try:
        with open(grub_cfg, encoding="utf-8", errors="replace") as f:
            lines = f.read().splitlines()
    except Exception:
        return False
    inside = False
    for ln in lines:
        st = ln.strip()
        # Uwaga: `menuentry_id_option="..."` z nagłówka grub.cfg też zaczyna się
        # od "menuentry" – wymagamy separatora, inaczej parser zgłasza fałszywy
        # alarm „wpis startowy bez initramfs”.
        if st.startswith("menuentry") and st[9:10] in (" ", "\t", "'", '"'):
            if inside:
                return True
            inside = True
            continue
        if not inside:
            continue
        if st.startswith("initrd"):
            return False
        if st == "}":
            return True
    return False


def _refresh_bootloader():
    """Odświeża wpisy bootloadera po zmianie jądra.

    Deploymenty (immutable OS): własny generator _update_grub_config().
    Zwykła instalacja: standardowy `grub-mkconfig` – /etc/grub.d/10_linux
    sam wygeneruje wpisy dla KAŻDEGO /boot/vmlinuz-* wraz z jego własnym
    initrd. Bez tego `pag upgrade kernel` zostawiał w menu STARY wpis:
    system startował ze starym jądrem, a nowe moduły leżały bezużyteczne
    ("moduły 7.2.8 na jądrze 7.2.5" → zawieszenie na starcie).
    """
    try:
        if _load_deployments():
            _update_grub_config()
            return
    except Exception:
        pass
    grub_cfg = "/boot/grub/grub.cfg"
    if not os.path.isdir("/boot/grub"):
        return
    # Zanim wygenerujemy menu: napraw dane wejściowe. Inaczej grub-mkconfig
    # albo się wywali, albo wygeneruje wpis bez initramfs.
    for _f in ("/etc/default/grub", "/boot/grub/grub.cfg.exemple"):
        if _strip_crlf(_f):
            print("  🧹 " + _('crlf_fixed', _f))
    if _repair_initramfs_links():
        print("  🔗 " + _('initramfs_links_fixed'))
    for tool, cmd in ((
            "grub-mkconfig", ["grub-mkconfig", "-o", grub_cfg]), (
            "grub2-mkconfig", ["grub2-mkconfig", "-o", grub_cfg])):
        if shutil.which(tool):
            try:
                print(_('  📋 Regenerating GRUB (grub-mkconfig)...'))
                r = subprocess.run(cmd, capture_output=True, text=True,
                                   errors="replace", timeout=180)
                if r.returncode != 0:
                    tail = [x for x in (r.stderr or r.stdout or "").splitlines() if x.strip()]
                    print("  ⚠ " + _('grub_failed', tail[-1] if tail else r.returncode))
                elif _grub_entry_lacks_initrd(grub_cfg):
                    print("  ⚠ " + _('grub_no_initrd'))
                else:
                    print("  ✅ " + _('grub_refreshed'))
            except Exception:
                pass
            return


def _update_grub_config():
    """
    Generuje wpisy GRUB dla wszystkich deploymentów.
    Każdy deployment dostaje własny wpis – rollback możliwy z bootloadera.
    """
    grub_cfg = "/boot/grub/grub.cfg"
    if not os.path.exists(os.path.dirname(grub_cfg)):
        return  # brak GRUB

    deployments = _load_deployments()
    root_dev = _detect_root_device()
    if not root_dev:
        print(_('  ⚠ Could not detect the root partition – GRUB entries will have no root=.'),
              file=sys.stderr)
        print(_('     Set PAG_ROOT_DEVICE=/dev/... (or PAG_GRUB_ROOT) and retry.'),
              file=sys.stderr)
    root_arg = f" root={root_dev}" if root_dev else ""

    lines = [
        "# =====================================================================",
        "# Pagan Linux – GRUB config (wygenerowane przez pag grub-update)",
        f"# Data: {datetime.now().isoformat()}",
        "# =====================================================================",
        "",
    ]

    # Domyślny – ostatni (najnowszy) deployment
    if deployments:
        latest = deployments[-1]["id"]
        lines.append(f"set default=0")
        lines.append(f"set timeout=5")
    else:
        lines.append("set default=0")
        lines.append("set timeout=5")
    lines.append("")

    # Wpisy dla każdego deploymentu (od najnowszego)
    entry_num = 0
    for d in reversed(deployments):
        deploy_dir = os.path.join(DEPLOYMENTS_DIR, d["id"])
        boot_dir = os.path.join(deploy_dir, "boot")
        kernels = sorted(
            [f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
            reverse=True
        ) if os.path.isdir(boot_dir) else []

        kernel_path = f"/.deployments/{d['id']}/boot/{kernels[0]}" if kernels else ""
        initrd_path = f"/.deployments/{d['id']}/boot/initramfs.img"
        initrd_line = f"initrd {initrd_path}" if os.path.exists(os.path.join(boot_dir, "initramfs.img")) else ""

        active_mark = f" [{_('active_deployment')}]" if d.get("active") else ""
        pkg_list = ", ".join(d.get("packages", [])[:3])
        label = f"Pagan Linux – {d['id']}{active_mark}"

        lines.append(f"menuentry '{label}' {{")
        if kernel_path:
            lines.append(f"    linux {kernel_path}{root_arg} rw quiet")
        else:
            lines.append(f"    # Brak jądra w tym deploymencie")
        if initrd_line:
            lines.append(f"    {initrd_line}")
        lines.append("}")
        lines.append("")
        entry_num += 1

    # Snapshoty systemu (btrfs) – każdy jako osobny wpis do uruchomienia.
    _snap_lines = _grub_snapshot_entries()
    if _snap_lines:
        lines.append("# --- Snapshoty systemu (CoW) ---")
        lines.extend(_snap_lines)

    # Wpis fallback: zwykły root (gdyby wszystko padło).
    # Uwaga: GRUB NIE rozwija globów – trzeba podać KONKRETNY plik jądra
    # (wcześniejsze `linux /boot/vmlinuz-*` było niepoprawne).
    fallback_kernels = sorted(
        [f for f in os.listdir("/boot") if f.startswith("vmlinuz-")],
        reverse=True
    ) if os.path.isdir("/boot") else []
    # Osobna partycja /boot => GRUB ma ją w `root`, ścieżki BEZ /boot.
    _bp = _boot_prefix()
    lines.append(f"menuentry '{_('grub_fallback_label')}' {{")
    if fallback_kernels:
        lines.append(f"    linux {_bp}/{fallback_kernels[0]}{root_arg} rw quiet")
        _fi = _initrd_for_kernel("/boot", fallback_kernels[0])
        if _fi:
            lines.append(f"    initrd {_bp}/{_fi}")
    else:
        lines.append("    # Brak jądra w /boot")
    lines.append("}")
    lines.append("")

    # Zapisz
    os.makedirs(os.path.dirname(grub_cfg), exist_ok=True)
    with open(grub_cfg, "w") as f:
        f.write("\n".join(lines))

    print(_('  📋 GRUB config updated – entries for each deployment'))


def _root_device_from_fstab(path: str = "/etc/fstab") -> str:
    """Zwraca DEVICE z wpisu dla '/' w fstab (pomija komentarze)."""
    try:
        with open(path, "r", encoding="utf-8", errors="replace") as fh:
            for line in fh:
                line = line.split("#", 1)[0].strip()
                if not line:
                    continue
                parts = line.split()
                if len(parts) >= 2 and parts[1] == "/":
                    return parts[0]
    except OSError:
        pass
    return ""


def _in_chroot() -> bool:
    """Heurystyka: czy działamy w chrocie (build ISO/IMG)?

    W chrocie /proc/1/root to root HOSTA – inny system plików niż nasz '/'.
    Na zwykłym systemie PID 1 ma root równy '/'. PAGAN_ROOT ustawiają skrypty
    budujące i jest dziedziczony przez chroot (dodatkowa wskazówka).
    """
    if os.environ.get("PAG_IN_CHROOT") == "1":
        return True
    if os.environ.get("PAGAN_ROOT"):
        return True
    try:
        return os.stat("/").st_dev != os.stat("/proc/1/root").st_dev
    except OSError:
        return False


def _detect_root_device() -> str:
    """Wykrywa urządzenie/identyfikator partycji root dla GRUB (root=...).

    Kolejność (od najbardziej wiarygodnego w danym kontekście):
      1) PAG_ROOT_DEVICE / PAG_GRUB_ROOT – jawny override (build ISO/IMG,
         instalator); najpewniejszy, bo nie zgadujemy.
      2) /etc/fstab TARGETU – w chrocie findmnt '/' zwraca partycję HOSTA,
         a fstab opisuje target (np. root=/dev/sda2 dla obrazu IMG).
      3) findmnt '/' – na żywym systemie (obsługuje UUID/LUKS/subvol).
    Zwraca "" gdy nie da się ustalić – wtedy GRUB nie dostaje błędnego root=.
    """
    explicit = (os.environ.get("PAG_ROOT_DEVICE")
                or os.environ.get("PAG_GRUB_ROOT") or "").strip()
    if explicit:
        return explicit

    fstab_dev = _root_device_from_fstab()
    if _in_chroot() and fstab_dev:
        return fstab_dev

    try:
        result = subprocess.run(
            ["findmnt", "-n", "-o", "SOURCE", "/"],
            capture_output=True, text=True, timeout=5
        )
        if result.returncode == 0 and result.stdout.strip():
            return result.stdout.strip()
    except Exception:
        pass

    # Ostatnia deska: fstab targetu (lepsze niż hardkodowane /dev/sda1,
    # które na sprzęcie z NVMe dawało niebootowalny system).
    return fstab_dev


def cmd_grub_update():
    """Ręcznie regeneruje konfigurację GRUB (deploymenty + snapshoty)."""
    ensure_dirs()
    print(_('📋 Updating GRUB configuration...'))
    _ensure_snapshot_grub_script()
    # Deploymenty mają własny generator; zwykły system – grub-mkconfig,
    # który uruchomi /etc/grub.d/40_pagan_snapshots i zachowa pozostałe wpisy.
    _refresh_bootloader()
    print(_('✅ GRUB updated.'))
    return 0

def cmd_deploy_list():
    """Wyświetla listę wszystkich deploymentów."""
    deployments = _load_deployments()
    if not deployments:
        print(_("no_deployments")); return

    print(_("deployments_list", len(deployments)))
    active = os.readlink(ACTIVE_LINK) if os.path.islink(ACTIVE_LINK) else ""

    for d in reversed(deployments):
        marker = f" ◀ {_('active_deployment')}" if d.get("active") or d["id"] == os.path.basename(active) else ""
        print(f"  {d['id']}{marker}")
        print(f"     {_action_label(d['action'])}: {', '.join(d['packages'][:5])}")
        if len(d.get('packages', [])) > 5:
            print(_('     +{arg1} more...', arg1=(len(d['packages']) - 5)))
        print(f"     {d['timestamp']}")


def cmd_deploy_rollback():
    """Przełącza na poprzedni deployment."""
    deployments = _load_deployments()
    active_indices = [i for i, d in enumerate(deployments) if d.get("active")]

    if len(deployments) < 2:
        print(f"❌ {_('deploy_rollback_fail')}"); return 1

    current_idx = active_indices[0] if active_indices else len(deployments) - 1
    prev_idx = current_idx - 1 if current_idx > 0 else -1

    if prev_idx < 0:
        print(f"❌ {_('deploy_rollback_fail')}"); return 1

    prev = deployments[prev_idx]
    prev_dir = os.path.join(DEPLOYMENTS_DIR, prev["id"])

    if not os.path.isdir(prev_dir):
        print(_('❌ Deployment {arg1} does not exist on disk', arg1=(prev['id']))); return 1

    print(_('⏪ Restoring deployment: {arg1}', arg1=(prev['id'])))
    print(f"   {prev['action']}: {', '.join(prev['packages'][:5])}")

    if not _ask_confirm():
        return 0

    _switch_deployment(prev_dir)

    for d in deployments:
        d["active"] = (d["id"] == prev["id"])
    _save_deployments(deployments)

    _update_grub_config()
    print(f"✅ {_('deploy_rollback_ok', prev['id'])}")
    print(_('  💡 Restart required to reload the system.'))
    return 0


def cmd_deploy_cleanup(keep: int = 3):
    """Usuwa stare deploymenty, zachowując ostatnie `keep`."""
    deployments = _load_deployments()

    if len(deployments) <= keep:
        print(f"✅ {_('deploy_cleanup_none', keep)}"); return 0

    to_remove = deployments[:-keep]
    removed = 0

    for d in to_remove:
        deploy_dir = os.path.join(DEPLOYMENTS_DIR, d["id"])
        if os.path.isdir(deploy_dir):
            shutil.rmtree(deploy_dir, ignore_errors=True)
            removed += 1

    remaining = deployments[-keep:]
    _save_deployments(remaining)

    print(f"✅ {_('deploy_cleanup_ok', removed)}")
    return 0


# =============================================================================
# POMOCNICZE
# =============================================================================

# Pakiety dostarczane przez bazowy system (zawsze "zainstalowane"). Wchodzą do
# rootfs z ISO przez data.tar.xz, więc NIE ma ich w repo.json ani w bazie pag –
# każda zależność od nich (glibc, bash, python3…) wyglądałaby na "brakującą".
# Współdzielone przez rozwijanie i weryfikację zależności.
SYSTEM_BASE = {
    "glibc", "libc", "gcc", "g++", "make", "binutils", "coreutils", "bash",
    "linux-api-headers", "kernel-headers", "zlib", "pkg-config", "pkgconf",
    "tar", "gzip", "xz", "bzip2", "findutils", "grep", "sed", "gawk", "awk",
    "diffutils", "patch", "file", "m4", "perl", "python3", "sh",
}


def _resolve_deps(names, repo, installed):
    resolved, visited = [], set()
    missing = []  # zależności których nie ma ani w repo ani zainstalowane

    def _is_base(dep):
        """True, gdy zależność dostarcza bazowy system (także przez provides)."""
        return dep in SYSTEM_BASE \
            or _resolve_provides(dep, repo, installed) in SYSTEM_BASE

    def visit(name, explicit=False):
        if name in visited: return

        # Rozwijanie wirtualnych zależności przez provides
        target = _resolve_provides(name, repo, installed)

        # Zależność dostarczana przez bazowy system – nie ma jej w repo ani w
        # bazie pag, więc nie "brakuje" jej i nie próbujemy jej instalować.
        # Wyjątek: nazwa podana wprost przez użytkownika (explicit=True).
        if not explicit and target in SYSTEM_BASE:
            return

        if target in visited: return
        visited.add(target)
        if target in repo:
            for dep in repo[target].dependencies:
                real_dep = _resolve_provides(dep, repo, installed)
                real_target = real_dep if real_dep in repo else dep

                if _is_base(dep):
                    continue

                # Sprawdź czy zależność jest dostępna
                if real_target not in installed and real_target not in repo:
                    if dep not in missing:
                        missing.append(dep)

                if dep not in installed:
                    visit(real_target)
        elif target not in installed:
            # Pakiet nie istnieje ani w repo ani zainstalowany
            if target not in missing:
                missing.append(target)

        if target not in installed and target not in resolved:
            resolved.append(target)

    for name in names:
        visit(name, explicit=True)

    # Zwróć brakujące (do sprawdzenia przez wywołującego)
    return resolved, missing

def _verify_dependencies(to_install: list, repo: dict, installed: dict) -> int:
    """
    Sprawdza czy wszystkie zależności pakietów do instalacji są spełnione.
    Zwraca liczbę brakujących zależności.
    """
    all_missing = []
    all_warnings = []

    for pkg_name in to_install:
        pkg = repo.get(pkg_name)
        if not pkg:
            continue

        for dep in pkg.dependencies:
            if dep in SYSTEM_BASE:
                continue  # bazowy system dostarcza tę zależność
            real_dep = _resolve_provides(dep, repo, installed)
            # Sprawdź czy zależność jest dostępna (w repo lub już zainstalowana)
            in_repo = real_dep in repo
            in_installed = real_dep in installed
            will_be_installed = real_dep in to_install

            if not in_repo and not in_installed and not will_be_installed:
                if dep not in all_missing:
                    all_missing.append((pkg_name, dep))
            elif in_repo and not in_installed and not will_be_installed:
                if dep not in [w[1] for w in all_warnings]:
                    all_warnings.append((pkg_name, dep, real_dep))

    if all_missing:
        print(_('\n❌ {arg1} – cannot install:', arg1=(_c('red', 'BRAKUJĄCE ZALEŻNOŚCI'))))
        for pkg, dep in all_missing:
            print(_('   {arg1} → needs {arg2} (missing from repositories)', arg1=(pkg), arg2=(_c('red', dep))))
        print()

    if all_warnings:
        print(_('\n⚠ {arg1} – will be installed as dependencies:', arg1=(_c('yellow', 'NIESPEŁNIONE ZALEŻNOŚCI'))))
        for pkg, dep, real in all_warnings:
            print(_('   {arg1} → {arg2} ({arg3} – will be downloaded)', arg1=(pkg), arg2=(dep), arg3=(_c('green', real))))
        print()

    return len(all_missing)

# Biblioteki bazowe (glibc/gcc runtime) – zawsze dostępne, nie wymagają pakietu
BASE_SO = {
    "libc.so.6", "libm.so.6", "libpthread.so.0", "libdl.so.2", "librt.so.1",
    "libutil.so.1", "libresolv.so.2", "libnsl.so.1", "libcrypt.so.1",
    "ld-linux.so.2", "ld-linux-x86-64.so.2", "ld-linux-aarch64.so.1",
    "libgcc_s.so.1", "linux-vdso.so.1",
}

def _verify_so_deps(to_install: list, repo: dict, installed: dict) -> int:
    """Sprawdza wymagania ABI (provides_so / requires_so z metadata.json).

    Fail-closed TYLKO gdy metadata jawnie deklaruje requires_so, a żaden pakiet
    (bazowy, zainstalowany lub instalowany w tej transakcji) nie dostarcza
    wymaganej wersji biblioteki. Stare pakiety bez tych pól są pomijane.
    """
    provided = set(BASE_SO)
    for n in to_install:
        p = repo.get(n)
        if p:
            provided.update(p.provides_so or [])
    for n, info in installed.items():
        provided.update(info.get("provides_so", []) or [])

    # NAPRAWA: soname faktycznie obecne w systemie (ldconfig -p). Metadane
    # starych paczek (zbudowanych przed polem provides_so) ich nie deklaruja,
    # a biblioteki sa na dysku - bez tego fail-closed check blokuje legalne
    # aktualizacje (np. mesa -> libLLVM.so.22.1).
    try:
        import shutil as _sh, subprocess as _sp
        _ld = _sh.which("ldconfig")
        if _ld:
            _o = _sp.run([_ld, "-p"], capture_output=True, text=True).stdout
            for _ln in _o.splitlines():
                _ln = _ln.strip()
                if "=>" in _ln:
                    provided.add(_ln.split("=>")[0].strip().split()[0])
    except Exception:
        pass

    missing = []
    for n in sorted(to_install):
        p = repo.get(n)
        if not p:
            continue
        for so in (p.requires_so or []):
            if so not in provided:
                missing.append((n, so))

    if missing:
        print(f"\n❌ {_c('red', 'BRAK WYMAGANYCH BIBLIOTEK (ABI so-name)')}:")
        for n, so in missing:
            print(_('   {arg1} → requires {arg2} – no package provides this version', arg1=(n), arg2=(_c('red', so))))
        print()
    return len(missing)

def _download_pkg(pkg, attempts: int = 3, progress: bool = True,
                  on_progress=None, on_log=None):
    """Pobiera pakiet do cache.

    `progress=False` wycisza pojedynczy pasek (np. gdy równoległy pobierający
    pokazuje własny panel zbiorczy). `on_progress(downloaded, total)` pozwala
    takiemu panelowi śledzić postęp bez wypisywania własnych linii, a
    `on_log(text)` przekierowuje komunikaty (ponowienia, błędy) do panelu,
    żeby nie rozbijały jego wielolinijkowego układu.
    """
    def _log(msg: str) -> None:
        if on_log is not None:
            on_log(msg)
        else:
            print(msg, file=sys.stderr)

    url = f"{pkg.repo_url}/{pkg.filename}"
    dest = os.path.join(PAG_CACHE, pkg.filename)
    if os.path.exists(dest) and (not pkg.sha256 or _sha256_file(dest) == pkg.sha256):
        _download_pkg_sig(pkg, dest)  # upewnij się, że sygnatura jest w cache
        return dest
    last_err = None
    for attempt in range(1, attempts + 1):
        try:
            req = Request(url, headers={"User-Agent":"pag/3.0"})
            with urlopen(req, timeout=600) as resp:
                total = int(resp.headers.get("Content-Length", 0))
                bar = DownloadBar(pkg.filename, total) if progress else None
                done = 0
                try:
                    with open(dest, "wb") as f:
                        while True:
                            chunk = resp.read(65536)
                            if not chunk:
                                break
                            f.write(chunk)
                            done += len(chunk)
                            if bar is not None:
                                bar.update(len(chunk))
                            if on_progress is not None:
                                on_progress(done, total)
                finally:
                    if bar is not None:
                        bar.close()
            if pkg.sha256 and _sha256_file(dest) != pkg.sha256:
                last_err = _("sha256_mismatch")
                try:
                    os.remove(dest)
                except OSError:
                    pass
                if attempt < attempts:
                    _log(_('  ↻ Retrying download of {arg1} ({arg2}/{arg3})...', arg1=(pkg.filename), arg2=(attempt), arg3=(attempts - 1)))
                    time.sleep(attempt)
                    continue
                return None
            _download_pkg_sig(pkg, dest)
            return dest
        except Exception as e:
            last_err = e
            # Usuń częściowy plik – bez tego mógłby zostać użyty jako „cache”
            # (gdy pakiet nie ma sha256) albo mylić kolejną próbę.
            try:
                if os.path.exists(dest):
                    os.remove(dest)
            except OSError:
                pass
            if attempt < attempts:
                _log(_('  ↻ Retrying download of {arg1} ({arg2}/{arg3})...', arg1=(pkg.filename), arg2=(attempt), arg3=(attempts - 1)))
                time.sleep(attempt)
                continue
    _log(_('  ⚠ Download error {arg1}: {arg2}', arg1=(pkg.filename), arg2=(last_err)))
    return None

def _download_pkg_sig(pkg, dest):
    """Zapewnia AKTUALNY podpis pakietu (.asc, fallback .sig) w cache.

    Istniejący podpis jest używany tylko wtedy, gdy faktycznie weryfikuje TĘ
    paczkę. Inaczej po przebudowie tej samej wersji (ten sam plik, nowy sha256)
    stary podpis zostawał obok nowej paczki i weryfikacja dawała fałszywe
    „NIEPRAWIDŁOWY PODPIS GPG”.
    """
    for ext in (".asc", ".sig"):
        sig_dest = dest + ext
        if os.path.exists(sig_dest):
            ok, _fp = _gpg_verify_fp(sig_dest, dest)
            if ok:
                return
    for ext in (".asc", ".sig"):
        sig_dest = dest + ext
        try:
            req = Request(f"{pkg.repo_url}/{pkg.filename}{ext}", headers={"User-Agent":"pag/3.0"})
            with urlopen(req, timeout=30) as resp:
                data = resp.read()
        except Exception:
            continue
        # nie mieszaj rozszerzeń – zostaje tylko ten wariant podpisu
        for other in (".asc", ".sig"):
            if other != ext:
                try:
                    os.remove(dest + other)
                except OSError:
                    pass
        with open(sig_dest, "wb") as f:
            f.write(data)
        return
    # Nie udało się pobrać podpisu – usuń nieaktualny z cache, żeby weryfikacja
    # nie porównywała paczki z podpisem od innej wersji (czytelny „BRAK PODPISU”).
    for other in (".asc", ".sig"):
        try:
            os.remove(dest + other)
        except OSError:
            pass

def _download_packages_parallel(pkgs: List[PackageInfo], max_workers: int = 4) -> Dict[str, Optional[str]]:
    """
    Równoległe pobieranie wielu pakietów przez ThreadPoolExecutor.
    Znacząco przyspiesza przy dużych aktualizacjach (50+ pakietów).

    Każdy aktywny wątek ma własną linię w panelu: procent, nazwa pakietu,
    pobrane/rozmiar i ETA (patrz `_ParallelDownloadDisplay`).
    Zwraca słownik {nazwa_pakietu: ścieżka_lub_None}.
    """
    results = {}
    display = _ParallelDownloadDisplay(len(pkgs))

    def _worker(pkg: PackageInfo):
        sid = display.start(pkg.name, getattr(pkg, "size_bytes", 0) or 0)
        path = None
        try:
            path = _download_pkg(
                pkg, progress=False,
                on_progress=lambda done, total: display.progress(sid, done, total),
                on_log=display.log)
            return path
        finally:
            display.finish(sid, ok=bool(path))

    try:
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            future_to_pkg = {executor.submit(_worker, pkg): pkg for pkg in pkgs}
            for future in as_completed(future_to_pkg):
                pkg = future_to_pkg[future]
                try:
                    results[pkg.name] = future.result()
                except Exception:
                    results[pkg.name] = None
    finally:
        display.close()
    return results

def load_world():
    if not os.path.exists(WORLD_FILE): return set()
    return {l.strip() for l in open(WORLD_FILE) if l.strip()}

def save_world(w):
    with open(WORLD_FILE,"w") as f:
        for n in sorted(w): f.write(f"{n}\n")

def _find_orphans(installed, world):
    needed = set(world)
    changed = True
    while changed:
        changed = False
        for n in list(needed):
            for dep in installed.get(n,{}).get("dependencies",[]):
                if dep not in needed and dep in installed:
                    needed.add(dep); changed = True
    return {n for n in installed if n not in needed}

# =============================================================================
# MAIN
# =============================================================================

def cmd_sbom(argv):
    """pag sbom export [spdx|cyclonedx] – manifest SBOM zainstalowanych pakietów.

    Wypisuje na stdout JSON (SPDX 2.3 lub CycloneDX 1.5) z listą
    zainstalowanych pakietów, wersji, licencji i sum SHA256.
    """
    fmt = (argv[0] if argv else "spdx").lower()
    if fmt not in ("spdx", "cyclonedx"):
        print(_('❌ Format: spdx | cyclonedx'))
        return 1
    installed = load_json(INSTALLED_DB)
    if not installed:
        print("{}") if fmt == "cyclonedx" else print("{\"packages\": []}")
        return 0
    # metadata repo (licencje) – best-effort
    try:
        repo = fetch_all_packages()
    except Exception:
        repo = {}
    names = sorted(installed)
    created = datetime.now().astimezone().isoformat(timespec="seconds")

    def _license_of(name):
        p = repo.get(name)
        lic = getattr(p, "license", None) or []
        if isinstance(lic, list):
            lic = ", ".join(x for x in lic if x)
        return lic or "NOASSERTION"

    if fmt == "spdx":
        doc = {
            "spdxVersion": "SPDX-2.3",
            "dataLicense": "CC0-1.0",
            "SPDXID": "SPDXRef-DOCUMENT",
            "name": "PaganOS-installed",
            "documentNamespace": f"https://repo.paganlinux.eu/sbom/installed-{int(time.time())}",
            "creationInfo": {
                "created": created,
                "creators": [f"Tool: pag-{PAG_VERSION}"],
            },
            "packages": [],
        }
        for i, n in enumerate(names):
            info = installed[n]
            doc["packages"].append({
                "SPDXID": f"SPDXRef-Package-{i+1}",
                "name": n,
                "versionInfo": info.get("version", ""),
                "downloadLocation": info.get("repo", "NOASSERTION"),
                "filesAnalyzed": False,
                "licenseConcluded": _license_of(n),
                "checksums": [{"algorithm": "SHA256", "checksumValue": info.get("sha256", "")}],
            })
    else:  # cyclonedx
        doc = {
            "bomFormat": "CycloneDX",
            "specVersion": "1.5",
            "serialNumber": f"urn:uuid:{str(uuid.uuid4())}",
            "version": 1,
            "metadata": {
                "timestamp": created,
                "tools": [{"vendor": "PaganOS", "name": "pag", "version": PAG_VERSION}],
            },
            "components": [],
        }
        for n in names:
            info = installed[n]
            lic = _license_of(n)
            comp = {
                "type": "library",
                "name": n,
                "version": info.get("version", ""),
                "hashes": [{"alg": "SHA-256", "content": info.get("sha256", "")}],
            }
            if lic != "NOASSERTION":
                comp["licenses"] = [{"license": {"id": lic}}]
            doc["components"].append(comp)
    print(json.dumps(doc, indent=2, ensure_ascii=False))
    return 0


USAGE_EN = """pag v3 – Pagan Linux Package Manager

BASIC:
  pag install <pkg>...       Install packages
  pag remove  <pkg>...       Remove packages
  pag update                Update PACKAGES + system flatpaks (refreshes indexes)
  pag sync                  Refresh indexes + show pending updates (changes nothing)
  pag upgrade               Update SYSTEM (packages + flatpaks + kernel/initramfs/GRUB)
  pag list [--installed]     List available / installed
  pag search <query>         Search packages
  pag info   <pkg>           Package details
  pag files  <pkg>           List package files
  pag verify [--deep]        Verify integrity (--deep = SHA256 per file)
  pag clean                  Clear download cache
  pag stats                  System statistics
  pag download <pkg>...      Download packages to cache (offline prep)

ROLLING (base baked into the image):
  pag base [status]          Image packages vs. repo (what pag manages)
  pag base adopt [pkg...]    Adopt base packages from the repo (--dry-run = preview)

SECURITY:
  pag key-add <url|file>     Import GPG key
  pag key-list               List trusted keys
  pag key-remove <id>        Remove key
  pag key-trust <repo>       Pin repo signing key fingerprint (no TOFU)
  pag key-untrust <repo>     Forget repo fingerprint (back to TOFU)
  pag key-trusted            List pinned repo fingerprints

ADVANCED:
  pag why     <pkg>          Show why a package is installed
  pag rdepends <pkg>         Show which packages depend on a package
  pag autoremove             Auto-remove orphaned dependencies
  pag pin <pkg> [ver]        Pin package version
  pag unpin <pkg>            Unpin
  pag pinned                 List pinned
  pag history                Transaction history
  pag rollback               Rollback last transaction
  pag repair [--dry-run]     Reinstall packages with missing files
  pag remove-orphans         Remove orphaned deps
  pag repo-add <url> [name]  Add repository (drop-in /etc/pag/repos/)
  pag repo-list              List repositories
  pag sbom export [fmt]      SBOM manifest (spdx|cyclonedx)

FLATPAK:
  pag flatpak [<query>]      Search & install (smart)
  pag flatpak search <q>     Search Flathub
  pag flatpak install <id>   Install flatpak
  pag flatpak remove <id>    Remove flatpak
  pag flatpak list           List installed flatpaks
  pag flatpak update         Update all flatpaks
  pag flatpak info <id>      Show flatpak details
  pag update|upgrade --no-flatpak  Skip Flatpak updates

SNAPSHOTS (btrfs CoW):
  pag snapshot-list          List system snapshots
  pag snapshot-create [label] Create a snapshot now
  pag snapshot-rollback [id] Start from snapshot at next boot (GRUB)
  pag snapshot-delete <id>   Delete a snapshot

IMMUTABLE OS (PAG_IMMUTABLE=1):
  pag deploy-list            List all deployments
  pag deploy-rollback        Switch to previous deployment
  pag deploy-cleanup [N]     Remove old deployments (keep last N, default 3)
  pag initramfs-update       Rebuild initramfs for current kernel/deployment
  pag grub-update            Regenerate GRUB entries for all deployments
"""

USAGE_PL = """pag v3 – Pagan Linux Package Manager

PODSTAWOWE:
  pag install <pkg>...       Instalacja pakietów
  pag remove  <pkg>...       Usuwanie pakietów
  pag update                Pakiety + flatpaki systemowe (odświeża indeksy)
  pag sync                  Odśwież indeksy + info o aktualizacjach (nic nie zmienia)
  pag upgrade               System: pakiety + flatpaki + kernel/initramfs/GRUB
  pag list [--installed]     Lista dostępnych / zainstalowanych
  pag search <query>         Szukaj pakietów
  pag info   <pkg>           Szczegóły pakietu
  pag files  <pkg>           Lista plików pakietu
  pag verify [--deep]        Weryfikacja integralności
  pag clean                  Wyczyść cache pobierania
  pag stats                  Statystyki systemu
  pag download <pkg>...      Pobierz do cache (offline)

ROLLING (baza wypalona w obrazie):
  pag base [status]          Pakiety z obrazu vs repo (czym pag zarządza)
  pag base adopt [pkg...]    Adoptuj pakiety bazy z repo (--dry-run = podgląd)

BEZPIECZEŃSTWO:
  pag key-add <url|file>     Importuj klucz GPG
  pag key-list               Lista zaufanych kluczy
  pag key-remove <id>        Usuń klucz
  pag key-trust <repo>       Przypnij fingerprint klucza repo (bez TOFU)
  pag key-untrust <repo>     Zapomnij fingerprint repo (powrót do TOFU)
  pag key-trusted            Lista przypiętych fingerprintów repo

ZAAWANSOWANE:
  pag why     <pkg>          Dlaczego pakiet jest zainstalowany
  pag rdepends <pkg>         Które pakiety zależą od pakietu
  pag autoremove             Usuń osierocone zależności
  pag pin <pkg> [ver]        Przypnij wersję pakietu
  pag unpin <pkg>            Odepnij
  pag pinned                 Lista przypiętych
  pag history                Historia transakcji
  pag rollback               Cofnij ostatnią transakcję
  pag repair [--dry-run]     Napraw brakujące pliki pakietów (reinstalacja)
  pag remove-orphans         Usuń osierocone zależności
  pag repo-add <url> [nazwa] Dodaj repozytorium (drop-in w /etc/pag/repos/)
  pag repo-list              Lista repozytoriów
  pag sbom export [fmt]      Manifest SBOM (spdx|cyclonedx)

FLATPAK:
  pag flatpak [<query>]      Szukaj i instaluj
  pag flatpak search <q>     Szukaj na Flathub
  pag flatpak install <id>   Zainstaluj flatpak
  pag flatpak remove <id>    Usuń flatpak
  pag flatpak list           Lista zainstalowanych
  pag flatpak update         Aktualizuj wszystkie
  pag flatpak info <id>      Szczegóły flatpaka
  pag update|upgrade --no-flatpak  Pomiń aktualizację Flatpaków

SNAPSHOTY (btrfs CoW):
  pag snapshot-list          Lista snapshotów systemu
  pag snapshot-create [opis] Utwórz snapshot teraz
  pag snapshot-rollback [id] Uruchom snapshot przy następnym starcie (GRUB)
  pag snapshot-delete <id>   Usuń snapshot

IMMUTABLE OS (PAG_IMMUTABLE=1):
  pag deploy-list            Lista wdrożeń
  pag deploy-rollback        Przełącz na poprzednie wdrożenie
  pag deploy-cleanup [N]     Usuń stare wdrożenia (zachowaj N, domyślnie 3)
  pag initramfs-update       Przebuduj initramfs
  pag grub-update            Regeneruj wpisy GRUB"""

def _get_usage():
    # Plik językowy może dostarczyć klucz "usage" – wtedy wygrywa z wbudowanym.
    _u = T.get(LANG, {}).get("usage")
    if _u:
        return _u
    if LANG == "pl":
        return USAGE_PL
    return USAGE_EN


# =============================================================================
# EASTER EGG: PAG WROOM – wyścigi ASCII w stylu Commodore
# -----------------------------------------------------------------------------

def cmd_wroom():
    """Ukryta gra: `pag wroom`.

    Animowany top-down wyścig w ASCII: trzy pasy, ruszający się tor, przeciwnicy,
    punkty, ETA niepotrzebne – liczy się rekord. Sterowanie strzałkami (lub
    WSAD), P pauza, Q wyjście. Gra działa tylko na terminalu; poza TTY wypisuje
    krótką podpowiedź, a po wyjściu przywraca ekran i ustawienia terminala.
    """
    if not (sys.stdin.isatty() and sys.stdout.isatty()):
        print(_('wroom_terminal'))
        return 1
    if os.environ.get("TERM", "") == "dumb":
        print(_('wroom_terminal'))
        return 1
    try:
        import random
        import select
        import termios
        import tty
    except ImportError:
        print(_('wroom_terminal'))
        return 1

    ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")

    def _vlen(text):
        return len(ANSI_RE.sub("", text))

    def _vcut(text, width):
        """Przytnij linię do `width` WIDOCZNYCH kolumn (nie licząc ANSI)."""
        if _vlen(text) <= width:
            return text
        out, vis, i = [], 0, 0
        while i < len(text) and vis < width:
            m = ANSI_RE.match(text, i)
            if m:
                out.append(m.group(0))
                i = m.end()
                continue
            out.append(text[i])
            vis += 1
            i += 1
        return "".join(out)

    def _center(text, width):
        v = _vlen(text)
        if v >= width:
            return _vcut(text, width)
        pad = width - v
        return " " * (pad // 2) + text + " " * (pad - pad // 2)

    # --- geometria toru i sprite'y (każdy znak = 1 kolumna) -------------------
    SPR_ROOF = " ▄█▄ "
    SPR_BODY = "▐███▌"
    LANE_W = 8
    N_LANES = 3
    ROAD_W = LANE_W * N_LANES + 2
    MIN_W, MIN_H = 56, 16

    GLYPHS = {
        "P": ("████ ", "█   █", "████ ", "█    ", "█    "),
        "A": (" ███ ", "█   █", "█████", "█   █", "█   █"),
        "G": (" ████", "█    ", "█  ██", "█   █", " ████"),
        "W": ("█   █", "█   █", "█ █ █", "██ ██", "█   █"),
        "R": ("████ ", "█   █", "████ ", "█ █  ", "█  █ "),
        "O": (" ███ ", "█   █", "█   █", "█   █", " ███ "),
        "M": ("█   █", "██ ██", "█ █ █", "█   █", "█   █"),
    }

    def _logo():
        rows = []
        for r in range(5):
            line = ""
            for ch in "PAG WROOM":
                if ch == " ":
                    line += "   "
                else:
                    line += GLYPHS[ch][r] + " "
            rows.append(line.rstrip())
        return rows

    LOGO = _logo()

    state = {
        "phase": "title", "best": 0, "paused": False,
        "lane": 1, "x": 1.0, "speed": 90.0, "boost": 0.0,
        "distance": 0.0, "lives": 3, "opponents": [],
        "spawn": 0.8, "invuln": 1.0, "flash": 0.0,
        "scroll": 0.0, "time": 0.0, "road_h": 12,
    }

    def _new_game():
        state.update(phase="play", paused=False, lane=1, x=1.0,
                     speed=90.0, boost=0.0, distance=0.0, lives=3,
                     opponents=[], spawn=0.8, invuln=1.0, flash=0.0,
                     scroll=0.0, time=0.0)

    # --- wejście (bez blokowania) --------------------------------------------
    ARROWS = {"\x1b[D": "LEFT", "\x1b[C": "RIGHT",
              "\x1b[A": "UP", "\x1b[B": "DOWN",
              "\x1bOD": "LEFT", "\x1bOC": "RIGHT",
              "\x1bOA": "UP", "\x1bOB": "DOWN"}
    fd = sys.stdin.fileno()
    pending = ""

    def _keys():
        nonlocal pending
        keys = []
        try:
            ready, _, _ = select.select([fd], [], [], 0)
            if not ready:
                return keys
            data = pending + os.read(fd, 64).decode("utf-8", "ignore")
            pending = ""
        except (OSError, UnicodeDecodeError):
            return keys
        i = 0
        while i < len(data):
            if data[i] == "\x1b":
                # Niekompletna sekwencja strzałki – dokończymy w następnej
                # klatce. Sam ESC (bez reszty) nie wychodzi z gry: wyjściem
                # jest Q, więc przypadkowy Alt/strzałka nie zabija wyścigu.
                if i + 1 >= len(data):
                    pending = data[i:]
                    break
                if data[i + 1] not in "[O":
                    i += 1
                    continue
                if i + 2 >= len(data):
                    pending = data[i:]
                    break
                seq = data[i:i + 3]
                key = ARROWS.get(seq)
                if key:
                    keys.append(key)
                i += 3
                continue
            ch = data[i]
            i += 1
            if ch in "qQ":
                keys.append("QUIT")
            elif ch in "aA":
                keys.append("LEFT")
            elif ch in "dD":
                keys.append("RIGHT")
            elif ch in "wW":
                keys.append("UP")
            elif ch in "sS":
                keys.append("DOWN")
            elif ch in "pP":
                keys.append("PAUSE")
            elif ch in " \r\n rR":
                keys.append("START")
        return keys

    # --- rysowanie toru -------------------------------------------------------
    def _paint(row, start, text, color):
        cells, cols = row
        for i, ch in enumerate(text):
            pos = start + i
            if 0 <= pos < len(cells) and ch != " ":
                cells[pos] = ch
                cols[pos] = color

    def _render_cells(row):
        cells, cols = row
        parts, i = [], 0
        while i < len(cells):
            j = i
            while j + 1 < len(cells) and cols[j + 1] == cols[i]:
                j += 1
            seg = "".join(cells[i:j + 1])
            parts.append(_c(cols[i], seg) if cols[i] else seg)
            i = j + 1
        return "".join(parts)

    def _road_row(r, phase):
        cells = [" "] * ROAD_W
        cols = [None] * ROAD_W
        cells[0] = "║"
        cols[0] = "yellow"
        cells[-1] = "║"
        cols[-1] = "yellow"
        for sep in (LANE_W, LANE_W * 2):
            if (r + phase) % 4 < 2:
                cells[1 + sep] = "│"
                cols[1 + sep] = "dim"
        return cells, cols

    def _lane_start(pos, width):
        return int(round(1 + pos * LANE_W + (LANE_W - width) / 2))

    def _play_lines(W, H):
        road_h = max(6, H - 4)
        rows = [_center(_c("cyan", "PAG WROOM"), W)]
        hud = _('wroom_hud', arg1=(int(state["distance"])),
                arg2=(int(state["speed"])), arg3=(state["lives"]))
        rows.append(_center(hud, W))

        board = [_road_row(r, int(state["scroll"])) for r in range(road_h)]
        for o in state["opponents"]:
            base = int(round(o["y"]))
            for dy, spr in ((0, SPR_ROOF), (1, SPR_BODY)):
                rr = base + dy
                if 0 <= rr < road_h:
                    _paint(board[rr], _lane_start(o["lane"], len(spr)),
                           spr, o["color"])

        if not (state["invuln"] > 0 and int(state["time"] * 10) % 2):
            for dy, spr in ((0, SPR_ROOF), (1, SPR_BODY)):
                rr = road_h - 2 + dy
                _paint(board[rr], _lane_start(state["x"], len(spr)),
                       spr, "cyan")

        if state["flash"] > 0:
            _paint(board[road_h - 2], ROAD_W // 2 - 2, "BUM!", "red")

        left = max(0, (W - ROAD_W) // 2)
        right = max(0, W - ROAD_W - left)
        for r in range(road_h):
            rows.append(" " * left + _render_cells(board[r]) + " " * right)

        rows.append("")
        rows.append(_center(_c("dim", _('wroom_controls')), W))
        if state["paused"]:
            rows[H // 2] = _center(_c("yellow", _('wroom_paused')), W)
        return rows[:H]

    def _menu_lines(W, H, blink):
        block = []
        if W >= len(LOGO[0]) + 2:
            block.extend(_c("cyan", ln) for ln in LOGO)
        else:
            block.append(_c("cyan", "P A G   W R O O M"))
        block.append("")
        block.append(_c("dim", _('wroom_tagline')))
        if H >= 18:
            block.append("")
            block.append("  " + _c("cyan", "▄███▄") + "     " +
                         _c("red", "▄███▄") + "     " +
                         _c("yellow", "▄███▄"))
        if H >= 22:
            block.extend(["", _c("dim", 'LOAD "WROOM",8,1'),
                          _c("dim", "READY."), _c("dim", "RUN")])
        block.append("")
        if state["phase"] == "over":
            block.append(_c("red", _('wroom_over')))
            block.append("")
            block.append(_('wroom_score', arg1=(int(state["distance"]))))
            block.append(_('wroom_best', arg1=(state["best"])))
            block.append("")
            block.append(_('wroom_restart'))
        else:
            block.append(_('wroom_controls'))
            block.append("")
            block.append(_c("yellow", _('wroom_press')) if blink else "")

        top = max(0, (H - len(block)) // 2)
        rows = [""] * H
        for i, line in enumerate(block):
            if top + i < H:
                rows[top + i] = _center(line, W)
        return rows

    # --- fizyka i kolizje -----------------------------------------------------
    def _spawn():
        free = [lane for lane in range(N_LANES)
                if not any(o["lane"] == lane and o["y"] < 4
                           for o in state["opponents"])]
        if not free:
            return
        state["opponents"].append({
            "lane": random.choice(free),
            "y": -2.0,
            "speed": state["speed"] * random.uniform(0.45, 0.78),
            "color": random.choice(("red", "yellow", "green")),
        })

    def _update(dt):
        state["time"] += dt
        if state["phase"] != "play" or state["paused"]:
            return

        state["boost"] *= max(0.0, 1.0 - dt * 3.0)
        base = 90.0 + min(120.0, state["distance"] * 0.02)
        target = max(45.0, base + state["boost"])
        state["speed"] += (target - state["speed"]) * min(1.0, dt * 2.0)
        state["distance"] += state["speed"] * dt * 0.45
        state["scroll"] += state["speed"] * dt * 0.09
        state["x"] += (state["lane"] - state["x"]) * min(1.0, dt * 9.0)
        if state["invuln"] > 0:
            state["invuln"] = max(0.0, state["invuln"] - dt)
        if state["flash"] > 0:
            state["flash"] = max(0.0, state["flash"] - dt)

        state["spawn"] -= dt
        if state["spawn"] <= 0:
            _spawn()
            state["spawn"] = max(0.45, 1.35 - state["speed"] / 320.0)

        for o in list(state["opponents"]):
            o["y"] += (state["speed"] - o["speed"]) * dt * 0.06
            if o["y"] > state["road_h"] + 2 or o["y"] < -4:
                state["opponents"].remove(o)

        if state["invuln"] > 0:
            return
        player_cy = state["road_h"] - 1.0
        for o in list(state["opponents"]):
            if (abs((o["y"] + 1.0) - player_cy) < 1.25
                    and abs(o["lane"] - state["x"]) < 0.55):
                state["lives"] -= 1
                state["flash"] = 0.6
                state["invuln"] = 1.8
                state["speed"] = max(45.0, state["speed"] * 0.5)
                state["boost"] = 0.0
                state["opponents"].remove(o)
                state["opponents"] = [x for x in state["opponents"]
                                      if x["y"] < state["road_h"] - 5]
                try:
                    out.write("\a")
                    out.flush()
                except OSError:
                    pass
                if state["lives"] <= 0:
                    state["phase"] = "over"
                    state["best"] = max(state["best"],
                                        int(state["distance"]))
                break

    # --- pętla gry ------------------------------------------------------------
    old_attrs = termios.tcgetattr(fd)
    out = sys.stdout
    try:
        tty.setcbreak(fd)
        out.write("\x1b[?1049h\x1b[?25l\x1b[2J")
        out.flush()
        running = True
        last = time.monotonic()
        last_size = None
        while running:
            for key in _keys():
                if key == "QUIT":
                    running = False
                    break
                if state["phase"] in ("title", "over"):
                    if key == "START":
                        _new_game()
                elif key == "PAUSE":
                    state["paused"] = not state["paused"]
                elif state["paused"]:
                    continue
                elif key == "LEFT":
                    state["lane"] = max(0, state["lane"] - 1)
                elif key == "RIGHT":
                    state["lane"] = min(N_LANES - 1, state["lane"] + 1)
                elif key == "UP":
                    state["boost"] = min(55.0, state["boost"] + 14.0)
                elif key == "DOWN":
                    state["boost"] = max(-45.0, state["boost"] - 14.0)
            if not running:
                break

            size = shutil.get_terminal_size((80, 24))
            W, H = size.columns, size.lines
            if last_size != (W, H):
                last_size = (W, H)
                out.write("\x1b[2J")
            state["road_h"] = max(6, H - 4)

            now = time.monotonic()
            dt = min(0.1, max(0.0, now - last))
            last = now
            if W >= MIN_W and H >= MIN_H:
                _update(dt)

            if W < MIN_W or H < MIN_H:
                lines = [""] * H
                msg = _('wroom_too_small', arg1=(MIN_W), arg2=(MIN_H))
                lines[H // 2] = _center(_c("yellow", msg), W)
            elif state["phase"] == "play":
                lines = _play_lines(W, H)
            else:
                blink = int(time.monotonic() * 2) % 2 == 0
                lines = _menu_lines(W, H, blink)

            buf = ["\x1b[H"]
            for i, line in enumerate(lines):
                buf.append(_vcut(line, W))
                buf.append("\x1b[K")
                if i != len(lines) - 1:
                    buf.append("\n")
            out.write("".join(buf))
            out.flush()

            spent = time.monotonic() - now
            if spent < 1.0 / 20.0:
                time.sleep(1.0 / 20.0 - spent)
    finally:
        try:
            out.write("\x1b[0m\x1b[?25h\x1b[?1049l")
            out.flush()
        except OSError:
            pass
        termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
    return 0


def _extract_lang(outdir: str) -> int:
    """Eksport wbudowanych tłumaczeń do outdir/{pl,en}.json (+ klucz "usage").

    Używane przez recepturę pakietu (pag.pag), żeby tłumaczenia jechały RAZEM
    z wersją paga – po `pag install/upgrade pag` i self-update są zawsze zgodne.
    """
    os.makedirs(outdir, exist_ok=True)
    for _code in ("pl", "en"):
        _d = dict(T.get(_code, {}))
        _u = globals().get(f"USAGE_{_code.upper()}", "")
        if _u:
            _d["usage"] = _u
        _p = os.path.join(outdir, f"{_code}.json")
        with open(_p, "w", encoding="utf-8") as _fh:
            json.dump(_d, _fh, ensure_ascii=False, indent=2, sort_keys=True)
        print(_('  ✓ {arg1} ({arg2} keys)', arg1=(_p), arg2=(len(_d))))
    return 0


def main():
    # Ukryte (używane przy budowie pakietu): eksport tłumaczeń do plików
    if len(sys.argv) >= 3 and sys.argv[1] == "--lang-extract":
        sys.exit(_extract_lang(sys.argv[2]))
    if len(sys.argv) >= 2 and sys.argv[1] in ("--version", "-V", "version"):
        print(f"pag {PAG_VERSION}")
        sys.exit(0)
    if len(sys.argv) == 2 and sys.argv[1] in ("--help", "-h", "help"):
        print(_get_usage()); sys.exit(0)
    if len(sys.argv) < 2:
        print(_get_usage()); sys.exit(0)

    cmd = sys.argv[1]
    args = sys.argv[2:]

    # Python bez modułu ssl = brak HTTPS w urllib. Powiedz to wprost, zamiast
    # pokazywać mylące „unknown url type: https” przy każdej operacji sieciowej.
    if not _ssl_ok():
        print(f"  ⚠ {_('ssl_broken')}", file=sys.stderr)

    # `pag repair --dry-run`: diagnostyka bez roota (nic nie zmienia).
    if cmd == "repair" and "--dry-run" in args and os.geteuid() != 0:
        sys.exit(cmd_repair(dry_run=True) or 0)

    # --- Komendy TYLKO DO ODCZYTU (nie wymagają roota) ---
    READ_ONLY = {
        "list": lambda: cmd_list("--installed" in args),
        "search": lambda: cmd_search(args[0]) if args else print(_('Usage: pag search <query>')),
        "info": lambda: cmd_info(args[0]) if args else print(_('Usage: pag info <pkg>')),
        "files": lambda: cmd_files(args[0]) if args else print(_('Usage: pag files <pkg>')),
        "verify": lambda: cmd_verify("--deep" in args),
        "why": lambda: cmd_why(args[0]) if args else print(_('Usage: pag why <pkg>')),
        "rdepends": lambda: cmd_rdepends(args[0]) if args else print(_('Usage: pag rdepends <pkg>')),
        "stats": cmd_stats,
        "pinned": cmd_pinned,
        "history": cmd_history,
        "repo-list": cmd_repo_list,
        "key-list": cmd_key_list,
        "key-trusted": cmd_key_trusted,
        "flatpak": lambda: cmd_flatpak(args),
        "flatpak-search": lambda: cmd_flatpak_search(args[0]) if args else print(_('Usage: pag flatpak-search <query>')),
        "flatpak-list": cmd_flatpak_list,
        "flatpak-info": lambda: cmd_flatpak_info(args[0]) if args else print(_('Usage: pag flatpak-info <id>')),
        "deploy-list": cmd_deploy_list,
        "deploy": cmd_deploy_list,
        "snapshot-list": cmd_snapshot_list,
        "snapshots": cmd_snapshot_list,
        "snapshot-grub": cmd_snapshot_grub,
        "sbom": lambda: cmd_sbom(args),
        "wroom": cmd_wroom,          # easter egg – działa bez roota
    }

    if cmd in READ_ONLY:
        sys.exit(READ_ONLY[cmd]() or 0)

    # --- `pag base` / `pag base status`: tylko odczyt (bez roota i bez locka) ---
    # `pag base adopt` NIE wpada tutaj – idzie ścieżką komend zapisu (roota + lock
    # pilnuje wspólna obsługa niżej), żeby transakcja była bezpieczna.
    if cmd in ("base", "base-status") and not (args and args[0] in ("adopt", "register")):
        sys.exit(cmd_base_status() or 0)

    # --- Smart search: `pag <nazwa-pakietu>` → repo + Flathub + sugestie ---
    WRITE_CMDS = {
        "install", "remove", "update", "sync", "upgrade", "clean", "download",
        "autoremove", "remove-orphans", "pin", "unpin", "rollback",
        "repo-add", "key-add", "key-remove", "key-trust", "key-untrust",
        "self-update",
        "flatpak", "flatpak-install", "flatpak-remove", "flatpak-update",
        "deploy-rollback", "deploy-cleanup", "initramfs-update", "grub-update",
        "snapshot-create", "snapshot-delete", "snapshot-rollback",
        "base", "base-adopt", "base-register",
        "repair",
    }
    if cmd not in WRITE_CMDS:
        # Literówka komendy? (np. `pag instal steam` zamiast `pag install`) –
        # zasugeruj poprawną komendę ZAMIAST wpadać w smart search (który
        # potrafi wisieć na `flatpak search` aż do Ctrl-C).
        _known = set(READ_ONLY) | set(WRITE_CMDS)
        _known.discard("wroom")      # easter egg – nie podpowiadaj go w literówkach
        _close = difflib.get_close_matches(cmd, _known, n=1, cutoff=0.75)
        if _close:
            print(_("❌ Unknown command: '{arg1}'. Did you mean '{arg2}'?", arg1=(cmd), arg2=(_close[0])))
            print(_("   Run 'pag' without arguments to see the command list."))
            sys.exit(1)
        sys.exit(_smart_search(" ".join([cmd] + args)) or 0)

    # Obsługa flag globalnych (-y/--yes oraz transakcji/snapshotów)
    global_args = []
    for a in args:
        if a in ("-y", "--yes"):
            os.environ["PAG_YES"] = "1"
        elif a == "--dry-run":
            os.environ["PAG_DRY_RUN"] = "1"
            global_args.append(a)          # `repair`/`base adopt` czytają flagę
        elif a == "--snapshot":
            os.environ["PAG_SNAPSHOT"] = "always"
        elif a == "--no-snapshot":
            os.environ["PAG_SNAPSHOT"] = "never"
        elif a == "--atomic":
            os.environ["PAG_ATOMIC"] = "1"
        elif a == "--no-atomic":
            os.environ["PAG_ATOMIC"] = "0"
        elif a == "--no-flatpak":
            os.environ["PAG_FLATPAK"] = "0"
        elif a == "--flatpak":
            os.environ["PAG_FLATPAK"] = "1"
        else:
            global_args.append(a)
    args = global_args

    # --- Komendy ZAPISU (wymagają roota) ---
    if os.geteuid() != 0:
        print(f"❌ {_('root_required')}", file=sys.stderr); sys.exit(1)

    ensure_dirs()

    with DatabaseLock():
        # Auto-naprawa: backup z przerwanej transakcji (bez wpisu „success")
        # -> przywróć brakujące pliki, zanim cokolwiek innego zrobimy.
        _recover_interrupted_transactions()
        WRITE_COMMANDS = {
            "install": lambda: cmd_install(
            [a for a in args if a not in (
                "-f", "--force", "--dry-run", "--snapshot", "--no-snapshot",
                "--atomic", "--no-atomic", "--")],
            upgrade=("-f" in args or "--force" in args)),
            "remove": lambda: cmd_remove(args),
            "update": lambda: cmd_update(do_upgrade=True),
            "sync": lambda: cmd_update(do_upgrade=False),
            "upgrade": cmd_upgrade,
            "clean": cmd_clean,
            "download": lambda: cmd_download(args),
            "autoremove": cmd_autoremove,
            "remove-orphans": cmd_remove_orphans,
            "pin": lambda: cmd_pin(args[0], args[1] if len(args)>1 else ""),
            "unpin": lambda: cmd_unpin(args[0]) if args else print(_('Usage: pag unpin <pkg>')),
            "rollback": cmd_rollback,
            "repair": lambda: cmd_repair(dry_run="--dry-run" in args),
            "repo-add": lambda: cmd_repo_add(args[0], args[1] if len(args) > 1 else "") if args else print(_('Usage: pag repo-add <url> [name]')),
            "key-add": lambda: cmd_key_add(args[0]) if args else print(_('Usage: pag key-add <url|file>')),
            "key-remove": lambda: cmd_key_remove(args[0]) if args else print(_('Usage: pag key-remove <id>')),
            "key-trust": lambda: cmd_key_trust(args[0]) if args else print(_('Usage: pag key-trust <repo_url>')),
            "key-untrust": lambda: cmd_key_untrust(args[0]) if args else print(_('Usage: pag key-untrust <repo_url>')),
            "self-update": cmd_self_update,
            "flatpak": lambda: cmd_flatpak(args),
            "flatpak-install": lambda: _flatpak_smart_install(args) if args else print(_('Usage: pag flatpak-install <app>')),
            "flatpak-remove": lambda: _flatpak_smart_remove(args) if args else print(_('Usage: pag flatpak-remove <app>')),
            "flatpak-update": cmd_flatpak_update,
            "deploy-rollback": cmd_deploy_rollback,
            "deploy-cleanup": lambda: cmd_deploy_cleanup(int(args[0]) if args else 3),
            "snapshot-create": lambda: cmd_snapshot_create(" ".join(
                a for a in args if not a.startswith("-"))),
            "snapshot-delete": lambda: cmd_snapshot_delete(args[0]) if args else print(
                _('Usage: pag snapshot-delete <id>')),
            "snapshot-rollback": lambda: cmd_snapshot_rollback(
                args[0] if args else ""),
            "initramfs-update": cmd_initramfs_update,
            "grub-update": cmd_grub_update,
            "base": lambda: cmd_base_register(args) if (args and args[0] == "register") else cmd_base_adopt(args),
            "base-adopt": lambda: cmd_base_adopt(args),
            "base-register": lambda: cmd_base_register(args),
        }

        fn = WRITE_COMMANDS.get(cmd)
        if fn:
            sys.exit(fn() or 0)
        # Should never reach here – _smart_search handles unknowns
        sys.exit(_smart_search(" ".join([cmd] + args)) or 0)

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        # Ctrl-C (np. podczas flatpak search / pobierania) – bez tracebacka
        print(_('\n  ⚠ Interrupted (Ctrl-C).'))
        sys.exit(130)