#!/bin/bash
# ==============================================================================
#  ██████╗███████╗ ██████╗███████╗███████╗██████╗ ██████╗  ██████╗
#  ██╔════╝██╔════╝██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔═══██╗
#  ███████╗█████╗  ██║     █████╗  █████╗  ██████╔╝██████╔╝██║   ██║
#  ╚════██║██╔══╝  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██╔══██╗██║   ██║
#  ███████║███████╗╚██████╗██║     ███████╗██║  ██║██║  ██║╚██████╔╝
#  ╚══════╝╚══════╝ ╚═════╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝
#
#  SECFERRO DIVISION SERIES — TERMUX ULTIMATE SETUP
#  Author  : Anonymousik  ·  github.com/Anonymousik
#  Web     : Anonymousik.is-a.dev/script
#  Version : 5.0.0  ·  codename: IRONCLAD
#  License : MIT
# ==============================================================================

# ── UWAGA: NIE używamy set -e aby uniknąć przerwań na Androidzie/Termux ──────
# Każda krytyczna operacja sprawdza własny kod wyjścia przez sf_run / sf_try.

# ─────────────────────────────────────────────────────────────────────────────
# STAŁE
# ─────────────────────────────────────────────────────────────────────────────
SCRIPT_VERSION="5.0.0"
SCRIPT_CODENAME="IRONCLAD"
LOG_FILE="${HOME}/.secferro_install.log"
CONFIG_FILE="${HOME}/.secferro.conf"
REQUIRED_STORAGE_MB=400
TERMUX_PREFIX="${PREFIX:-/data/data/com.termux/files/usr}"

# ─────────────────────────────────────────────────────────────────────────────
# KOLORY
# ─────────────────────────────────────────────────────────────────────────────
R='\033[0;31m'  ; G='\033[0;32m' ; Y='\033[1;33m'
B='\033[0;34m'  ; P='\033[0;35m' ; C='\033[0;36m'
W='\033[1;37m'  ; DM='\033[2m'   ; BLD='\033[1m'
NC='\033[0m'

# ─────────────────────────────────────────────────────────────────────────────
# FLAGI MODUŁÓW
# ─────────────────────────────────────────────────────────────────────────────
M_WEB=false      # WebDev
M_ANDROID=false  # Android / Java
M_CYBER=false    # CyberSecurity & Pentest
M_FULL=false     # Compiled Languages
M_TOR=false      # Tor + ProxyChains
M_DOCKER=false   # Proot-Distro
M_DATA=false     # Data Science / ML
M_DEVOPS=false   # DevOps / Cloud / IaC
M_MEDIA=false    # Media / OSINT / Forensics
M_DB=false       # Databases
M_IOT=false      # IoT / Embedded
M_GAME=false     # Game Dev / Scripting

DRY_RUN=false
SKIP_UI=false
VERBOSE=false
DO_UNINSTALL=false
ERRORS=0         # Licznik błędów niekrityczynych

# ─────────────────────────────────────────────────────────────────────────────
# LOGGING
# ─────────────────────────────────────────────────────────────────────────────
_log_raw() { echo "[$(date '+%H:%M:%S')] [$1] $2" >> "$LOG_FILE"; }

sf_info()  { echo -e "${B}  [·]${NC} $*"; _log_raw "INFO"  "$*"; }
sf_ok()    { echo -e "${G}  [✓]${NC} $*"; _log_raw "OK"    "$*"; }
sf_warn()  { echo -e "${Y}  [!]${NC} $*"; _log_raw "WARN"  "$*"; }
sf_error() { echo -e "${R}  [✗]${NC} $*"; _log_raw "ERROR" "$*"; ERRORS=$((ERRORS+1)); }
sf_debug() { [[ "$VERBOSE" == true ]] && echo -e "${DM}  [D] $*${NC}"; _log_raw "DEBUG" "$*"; }
sf_fix()   { echo -e "${P}  [⚙]${NC} ${BLD}AUTO-FIX:${NC} $*"; _log_raw "FIX"   "$*"; }

sf_step() {
    echo ""
    echo -e "${C}${BLD}  ╔══════════════════════════════════════════════════╗${NC}"
    printf  "${C}${BLD}  ║  %-48s║${NC}\n" "$*"
    echo -e "${C}${BLD}  ╚══════════════════════════════════════════════════╝${NC}"
    _log_raw "STEP" "$*"
}

sf_phase() {
    echo ""
    echo -e "${Y}${BLD}  ▶ $* ${DM}[SECFERRO DIVISION]${NC}"
    echo -e "${DM}  $(printf '─%.0s' {1..52})${NC}"
    _log_raw "PHASE" "$*"
}

# ─────────────────────────────────────────────────────────────────────────────
# WYKONANIE POLECEŃ
# sf_run  → krytyczne: loguje błąd ale kontynuuje (nie wychodzi)
# sf_try  → opcjonalne: błąd = warning, bez licznika
# ─────────────────────────────────────────────────────────────────────────────
sf_run() {
    local cmd="$*"
    sf_debug "CMD: $cmd"
    if [[ "$DRY_RUN" == true ]]; then
        echo -e "  ${DM}[DRY] $cmd${NC}"
        return 0
    fi
    eval "$cmd" 2>&1 | tee -a "$LOG_FILE"
    local rc=${PIPESTATUS[0]}
    if [[ $rc -ne 0 ]]; then
        sf_error "Polecenie zakończone błędem (kod $rc): $cmd"
        return 1
    fi
    return 0
}

sf_try() {
    local cmd="$*"
    sf_debug "TRY: $cmd"
    [[ "$DRY_RUN" == true ]] && { echo -e "  ${DM}[DRY] $cmd${NC}"; return 0; }
    eval "$cmd" >> "$LOG_FILE" 2>&1 || sf_warn "Pominięto (opcjonalne): $cmd"
    return 0
}

# Instalacja pakietu pkg z obsługą błędu
pkg_install() {
    sf_info "Instaluję pakiety: $*"
    sf_run "pkg install -y $*"
}

# Instalacja pakietu pkg z fallback (nie przerywa)
pkg_try() {
    sf_info "Instaluję (opcjonalnie): $*"
    sf_try "pkg install -y $*"
}

# pip install z flagą wymaganą przez Termux
pip_install() {
    sf_info "pip install: $*"
    sf_try "pip install --quiet --break-system-packages $*"
}

# npm global install
npm_global() {
    sf_info "npm global: $*"
    sf_try "npm install -g --quiet $*"
}

# ─────────────────────────────────────────────────────────────────────────────
# PASEK POSTĘPU
# ─────────────────────────────────────────────────────────────────────────────
sf_progress() {
    local cur=$1 total=$2 label="${3:-...}"
    local w=36 filled=$(( cur * w / total )) empty
    empty=$(( w - filled ))
    local bar
    bar="$(printf '█%.0s' $(seq 1 $filled) 2>/dev/null)$(printf '░%.0s' $(seq 1 $empty) 2>/dev/null)"
    printf "\r${C}  [%s]${NC} ${DM}%d/%d %s${NC}" "$bar" "$cur" "$total" "$label"
    [[ $cur -eq $total ]] && echo ""
}

# ─────────────────────────────────────────────────────────────────────────────
# BANER
# ─────────────────────────────────────────────────────────────────────────────
print_banner() {
    clear
    echo -e "${C}${BLD}"
    echo "  ██████╗███████╗ ██████╗███████╗███████╗██████╗ ██████╗  ██████╗ "
    echo "  ██╔════╝██╔════╝██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔═══██╗"
    echo "  ███████╗█████╗  ██║     █████╗  █████╗  ██████╔╝██████╔╝██║   ██║"
    echo "  ╚════██║██╔══╝  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██╔══██╗██║   ██║"
    echo "  ███████║███████╗╚██████╗██║     ███████╗██║  ██║██║  ██║╚██████╔╝"
    echo "  ╚══════╝╚══════╝ ╚═════╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝"
    echo -e "${NC}"
    printf "  ${Y}${BLD}SECFERRO DIVISION SERIES${NC}  ${DM}v%s · %s${NC}\n" \
        "$SCRIPT_VERSION" "$SCRIPT_CODENAME"
    echo -e "  ${DM}github.com/Anonymousik  ·  Anonymousik.is-a.dev${NC}"
    printf  "  ${DM}%s${NC}\n" "$(date '+%Y-%m-%d %H:%M')"
    echo -e "  ${DM}Log: ${LOG_FILE}${NC}"
    echo -e "  ${P}$(printf '─%.0s' {1..56})${NC}"
    echo ""
}

# ─────────────────────────────────────────────────────────────────────────────
# LOADING SCREEN — animowany komunikat podczas długich operacji
# Użycie: sf_loading "Komunikat" &  →  LOADING_PID=$!
#         (robota)  →  sf_loading_done $LOADING_PID
# ─────────────────────────────────────────────────────────────────────────────
sf_loading() {
    local msg="$1"
    local frames=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
    local i=0
    while true; do
        printf "\r${C}  %s${NC} ${BLD}%s${NC}  " "${frames[$i]}" "$msg"
        i=$(( (i+1) % ${#frames[@]} ))
        sleep 0.08
    done
}

sf_loading_done() {
    local pid=$1 label="${2:-Gotowe}"
    kill "$pid" 2>/dev/null
    wait "$pid" 2>/dev/null
    printf "\r  ${G}✓${NC} ${BLD}%s${NC}%-30s\n" "$label" " "
}

# ─────────────────────────────────────────────────────────────────────────────
# ██████████████████████████████████████████████████████████████████████████████
#  PRE-FLIGHT: INTELIGENTNA WERYFIKACJA I AUTO-NAPRAWA ŚRODOWISKA
# ██████████████████████████████████████████████████████████████████████████████
# ─────────────────────────────────────────────────────────────────────────────
preflight() {
    sf_step "PRE-FLIGHT SYSTEM CHECK"
    local issues=0

    # ── 1. TERMUX DETECTION ───────────────────────────────────────────────────
    if [[ -n "${TERMUX_VERSION:-}" ]] || [[ -d "${TERMUX_PREFIX}" ]]; then
        sf_ok "Środowisko: Termux ${TERMUX_VERSION:-unknown}"
    else
        sf_warn "Środowisko nie-Termux — niektóre funkcje mogą być niedostępne"
    fi

    # ── 2. ANDROID SDK / API LEVEL ────────────────────────────────────────────
    local api
    api=$(getprop ro.build.version.sdk 2>/dev/null || echo "?")
    sf_ok "Android API Level: ${api}"
    if [[ "$api" != "?" ]] && [[ "$api" -lt 24 ]]; then
        sf_warn "Android API < 24 — niektóre pakiety mogą nie działać"
    fi

    # ── 3. DOSTĘP DO PAMIĘCI ZEWNĘTRZNEJ (auto-fix) ──────────────────────────
    if [[ ! -d "$HOME/storage" ]]; then
        sf_fix "Brak dostępu do storage — uruchamiam termux-setup-storage..."
        sf_info "Gdy pojawi się dialog systemu — kliknij ZEZWÓL"
        termux-setup-storage 2>/dev/null || sf_warn "termux-setup-storage niedostępny (normalny stan bez Termux:API)"
        sleep 2
    else
        sf_ok "Dostęp do storage: aktywny"
    fi

    # ── 4. POŁĄCZENIE SIECIOWE (curl, nie ping — ICMP zablokowane na Androidzie) ──
    sf_info "Sprawdzam połączenie sieciowe..."
    if curl -s --max-time 8 --head https://packages.termux.dev > /dev/null 2>&1; then
        sf_ok "Sieć: aktywna (packages.termux.dev osiągalne)"
    elif curl -s --max-time 8 --head https://cloudflare.com > /dev/null 2>&1; then
        sf_ok "Sieć: aktywna"
    else
        sf_error "Brak połączenia sieciowego — sprawdź Wi-Fi/dane i spróbuj ponownie"
        issues=$((issues+1))
    fi

    # ── 5. WOLNE MIEJSCE ──────────────────────────────────────────────────────
    local avail_mb
    avail_mb=$(df "$HOME" 2>/dev/null | awk 'NR==2 {printf "%d", $4/1024}')
    avail_mb=${avail_mb:-0}
    if [[ "$avail_mb" -ge "$REQUIRED_STORAGE_MB" ]]; then
        sf_ok "Wolne miejsce: ${avail_mb} MB"
    else
        sf_error "Za mało miejsca: ${avail_mb} MB (wymagane min. ${REQUIRED_STORAGE_MB} MB)"
        issues=$((issues+1))
    fi

    # ── 6. SPRAWDŹ I NAPRAW REPOZYTORIUM PKG ─────────────────────────────────
    sf_info "Weryfikuję repozytorium pkg..."
    local repo_ok=false
    if curl -s --max-time 6 https://packages.termux.dev > /dev/null 2>&1; then
        repo_ok=true
        sf_ok "Repozytorium Termux: dostępne"
    else
        sf_fix "Główne repo niedostępne — próbuję zmienić na mirror Cloudflare..."
        if [[ -f "${TERMUX_PREFIX}/etc/apt/sources.list" ]]; then
            cp "${TERMUX_PREFIX}/etc/apt/sources.list" \
               "${TERMUX_PREFIX}/etc/apt/sources.list.bak.$(date +%s)"
            echo "deb https://packages.termux.dev/apt/termux-main stable main" \
               > "${TERMUX_PREFIX}/etc/apt/sources.list"
            sf_ok "Mirror Cloudflare ustawiony"
        fi
    fi

    # ── 7. SPRAWDŹ DPKG LOCK (auto-fix) ──────────────────────────────────────
    local lockfile="${TERMUX_PREFIX}/var/lib/dpkg/lock-frontend"
    if [[ -f "$lockfile" ]]; then
        sf_fix "Wykryto blokadę dpkg — usuwam..."
        rm -f "$lockfile" \
              "${TERMUX_PREFIX}/var/lib/dpkg/lock" \
              "${TERMUX_PREFIX}/var/lib/apt/lists/lock" 2>/dev/null
        sf_ok "Blokada dpkg usunięta"
    fi

    # ── 8. UPRAWNIENIA KATALOGU HOME ─────────────────────────────────────────
    if [[ ! -w "$HOME" ]]; then
        sf_fix "Brak zapisu do HOME — próbuję naprawić chmod..."
        chmod 755 "$HOME" 2>/dev/null || sf_warn "Nie udało się zmienić uprawnień HOME"
    else
        sf_ok "Uprawnienia HOME: poprawne"
    fi

    # ── 9. WERSJA BASH ────────────────────────────────────────────────────────
    local bash_ver="${BASH_VERSION%%(*}"
    sf_ok "Bash: $bash_ver"

    # ── 10. UŻYTKOWNIK ────────────────────────────────────────────────────────
    sf_ok "Użytkownik: $(id -un 2>/dev/null || echo $USER)  UID=$(id -u)"

    # ── WYNIK PRE-FLIGHT ──────────────────────────────────────────────────────
    echo ""
    if [[ $issues -gt 0 ]]; then
        sf_warn "Pre-flight zakończony z $issues problemem(ami) krytycznymi."
        sf_warn "Instalacja będzie kontynuowana — niektóre moduły mogą się nie udać."
        sleep 2
    else
        sf_ok "Pre-flight OK — system gotowy do instalacji"
    fi
}

# ─────────────────────────────────────────────────────────────────────────────
# AKTUALIZACJA BAZY + PAKIETY BAZOWE
# ─────────────────────────────────────────────────────────────────────────────
setup_base() {
    sf_step "SYSTEM BASE"
    sf_phase "Aktualizacja repozytoriów i systemu"

    sf_info "pkg update — może potrwać kilka minut przy pierwszym uruchomieniu..."
    sf_run "pkg update -y"
    sf_run "pkg upgrade -y"

    sf_phase "Pakiety bazowe SECFERRO CORE"
    pkg_install "git curl wget zsh nano tmux openssh ncurses-utils \
                 procps findutils diffutils patch man"

    # termux-tools: ważne narzędzia systemowe Termuksa
    pkg_try "termux-tools"
    pkg_try "termux-api"

    sf_ok "Baza systemu zainstalowana"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 1: WebDev
# ─────────────────────────────────────────────────────────────────────────────
install_web() {
    sf_step "MODUŁ: WEBDEV"
    sf_phase "Runtime — Node.js, PHP, Python, Deno"

    pkg_install "nodejs-lts yarn php python deno"

    sf_phase "Narzędzia globalne npm"
    npm_global "typescript ts-node eslint prettier vite nodemon pm2 \
                http-server @biomejs/biome serve"

    sf_phase "Python — Web & API stack"
    pip_install "flask fastapi uvicorn httpx aiohttp requests \
                 python-dotenv pydantic rich typer"

    sf_phase "PHP Composer"
    if ! command -v composer > /dev/null 2>&1; then
        sf_info "Instaluję Composer..."
        curl -sS https://getcomposer.org/installer | php -- \
            --install-dir="${TERMUX_PREFIX}/bin" --filename=composer >> "$LOG_FILE" 2>&1 \
            && sf_ok "Composer zainstalowany" || sf_warn "Composer — błąd instalacji"
    else
        sf_ok "Composer już zainstalowany"
    fi

    sf_phase "Konfiguracja npm (bez sudo)"
    mkdir -p "$HOME/.npm-global"
    npm config set prefix "$HOME/.npm-global" >> "$LOG_FILE" 2>&1

    sf_ok "MODUŁ WebDev: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 2: Android Dev
# ─────────────────────────────────────────────────────────────────────────────
install_android() {
    sf_step "MODUŁ: ANDROID DEV"
    sf_phase "JVM — OpenJDK 17, Gradle, Kotlin"

    pkg_install "openjdk-17 gradle kotlin"
    pkg_try "aapt"

    sf_phase "Zmienne środowiskowe JVM"
    {
        echo ""
        echo "# SecFerro: Android Dev"
        echo "export JAVA_HOME=\$(dirname \$(dirname \$(readlink -f \$(which java))))"
        echo "export GRADLE_USER_HOME=\$HOME/.gradle"
        echo "export ANDROID_USER_HOME=\$HOME/.android"
    } >> "$HOME/.zshrc" 2>/dev/null
    mkdir -p "$HOME/.gradle" "$HOME/.android"

    sf_ok "MODUŁ Android Dev: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 3: CyberSecurity & Pentest
# ─────────────────────────────────────────────────────────────────────────────
install_cyber() {
    sf_step "MODUŁ: CYBERSECURITY"
    sf_phase "Skanowanie i rekonesans"

    pkg_install "nmap dnsutils whois netcat-openbsd net-tools iproute2"
    pkg_try "masscan"
    pkg_try "tcpdump"

    sf_phase "Narzędzia ataków i audytu"
    pkg_install "sqlmap hydra openssl-tool"
    pkg_try "aircrack-ng"
    pkg_try "hashcat"

    sf_phase "Python Security Arsenal"
    pip_install "scapy impacket pwntools paramiko cryptography \
                 requests[socks] beautifulsoup4 lxml"
    pip_install "shodan censys" # OSINT APIs

    sf_phase "Nikto — Web Vulnerability Scanner"
    if [[ ! -d "$HOME/tools/nikto" ]]; then
        mkdir -p "$HOME/tools"
        sf_loading "Klonuję Nikto..." &
        local pid=$!
        git clone --depth=1 -q https://github.com/sullo/nikto \
            "$HOME/tools/nikto" >> "$LOG_FILE" 2>&1
        sf_loading_done $pid "Nikto sklonowany"
    else
        sf_ok "Nikto już zainstalowany"
    fi

    sf_phase "Metasploit (opcjonalnie — duży pakiet)"
    pkg_try "metasploit"

    sf_phase "Konfiguracja aliasów CyberSec"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: CyberSec aliases
alias nikto='perl $HOME/tools/nikto/program/nikto.pl'
alias scan='nmap -sV -sC --open'
alias myip-pub='curl -s https://ipinfo.io/ip'
alias myip-full='curl -s https://ipinfo.io/json | python3 -m json.tool'
alias hosts='cat /etc/hosts'
alias listening='ss -tlnp'
alias arpscan='nmap -sn'
EOF

    sf_ok "MODUŁ CyberSecurity: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 4: Fullstack Compiled
# ─────────────────────────────────────────────────────────────────────────────
install_fullstack() {
    sf_step "MODUŁ: FULLSTACK COMPILED"
    sf_phase "Języki systemowe — Rust, Go, C/C++, Lua"

    pkg_install "rust golang clang make cmake ninja lua54"

    sf_phase "Cargo tools"
    sf_try "cargo install cargo-watch cargo-edit" # async, nie blokuje

    sf_phase "Go tools"
    sf_try "go install github.com/air-verse/air@latest" # hot-reload

    sf_phase "Build tools"
    pkg_try "autoconf automake libtool pkg-config"
    pkg_try "llvm"

    sf_ok "MODUŁ Fullstack: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 5: Tor + ProxyChains
# ─────────────────────────────────────────────────────────────────────────────
install_tor() {
    sf_step "MODUŁ: TOR & PROXYCHAINS"
    sf_phase "Instalacja Tora i ProxyChains"

    pkg_install "tor proxychains-ng"

    sf_phase "Konfiguracja ProxyChains (dynamic chain)"
    local pc="${TERMUX_PREFIX}/etc/proxychains.conf"
    if [[ -f "$pc" ]]; then
        cp "$pc" "${pc}.bak" 2>/dev/null
        # Przełącz na dynamic_chain
        sed -i 's/^strict_chain/#strict_chain/'   "$pc" 2>/dev/null
        sed -i 's/^random_chain/#random_chain/'   "$pc" 2>/dev/null
        sed -i 's/^#\s*dynamic_chain/dynamic_chain/' "$pc" 2>/dev/null
        # Dodaj Tor SOCKS5 jeśli brak
        grep -q "socks5 127.0.0.1 9050" "$pc" 2>/dev/null || \
            echo "socks5  127.0.0.1  9050" >> "$pc"
        sf_ok "ProxyChains: dynamic chain → Tor SOCKS5:9050"
    fi

    sf_phase "Konfiguracja torrc (hardened)"
    local torrc="${TERMUX_PREFIX}/etc/tor/torrc"
    mkdir -p "$(dirname "$torrc")" 2>/dev/null
    [[ -f "$torrc" ]] && cp "$torrc" "${torrc}.bak" 2>/dev/null
    cat > "$torrc" << 'TORRC'
# SecFerro: Hardened torrc
SocksPort 9050
DNSPort 5353
AutomapHostsOnResolve 1
ExcludeExitNodes {RU},{CN},{BY},{KP}
StrictNodes 1
TORRC
    sf_ok "torrc skonfigurowany"

    sf_phase "Aliasy Tor"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: Tor helpers
alias tor-start='tor -f $PREFIX/etc/tor/torrc &>/dev/null & echo "[SecFerro] Tor PID: $!"'
alias tor-stop='pkill -f "tor -f" && echo "[SecFerro] Tor zatrzymany"'
alias tor-status='pgrep -a tor && echo "[ON]" || echo "[OFF]"'
alias tor-check='curl --socks5-hostname 127.0.0.1:9050 -s https://check.torproject.org/api/ip'
alias tor-ip='curl --socks5-hostname 127.0.0.1:9050 -s https://ipinfo.io/ip'
alias prox='proxychains4 -q'
alias anon='proxychains4 -q'
EOF

    sf_ok "MODUŁ Tor+ProxyChains: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 6: Docker / Proot-Distro
# ─────────────────────────────────────────────────────────────────────────────
install_docker() {
    sf_step "MODUŁ: PROOT-DISTRO (DOCKER ALTERNATIVE)"
    sf_phase "Instalacja proot-distro"

    pkg_install "proot-distro proot"

    sf_phase "Instalacja Ubuntu 22.04 LTS"
    if proot-distro list 2>/dev/null | grep -q "ubuntu"; then
        sf_ok "Ubuntu LTS: już zainstalowany"
    else
        sf_info "Pobieranie Ubuntu LTS rootfs (~200 MB) — może chwilę potrwać..."
        sf_loading "Pobieranie Ubuntu LTS..." &
        local pid=$!
        proot-distro install ubuntu >> "$LOG_FILE" 2>&1
        sf_loading_done $pid "Ubuntu LTS zainstalowany"
    fi

    sf_phase "Aliasy proot"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: proot-distro
alias ubuntu='proot-distro login ubuntu'
alias pdl='proot-distro list'
alias pdr='proot-distro remove'
EOF

    sf_ok "MODUŁ Proot-Distro: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 7: Data Science / ML / AI
# ─────────────────────────────────────────────────────────────────────────────
install_data() {
    sf_step "MODUŁ: DATA SCIENCE / ML"
    sf_phase "Python core stack"

    pkg_install "python python-pip python-numpy scipy"
    pkg_try "python-pandas"

    sf_phase "ML & Analytics (pip)"
    pip_install "numpy pandas matplotlib seaborn plotly scikit-learn"
    pip_install "jupyter notebook ipython"
    pip_install "transformers datasets tokenizers"  # HuggingFace
    pip_install "polars"                             # fast DataFrame (Rust-backed)
    pip_install "duckdb"                             # in-process analytics SQL

    sf_phase "Aliasy Data Science"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: Data Science
alias jnb='jupyter notebook --no-browser --ip=127.0.0.1'
alias ipy='ipython'
alias py='python3'
EOF

    sf_ok "MODUŁ Data Science / ML: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 8: DevOps / Cloud / IaC
# ─────────────────────────────────────────────────────────────────────────────
install_devops() {
    sf_step "MODUŁ: DEVOPS / CLOUD / IaC"
    sf_phase "Konteneryzacja i orkiestracja"

    pkg_try "kubectl"
    pkg_try "helm"
    pkg_try "k9s"

    sf_phase "IaC — Terraform / Ansible"
    pkg_try "terraform"
    pip_install "ansible ansible-core"

    sf_phase "CI/CD & Narzędzia DevOps"
    pkg_install "jq yq"
    pkg_try "gh"        # GitHub CLI
    pkg_try "act"       # Run GitHub Actions locally

    sf_phase "SSH & Tunelowanie"
    pkg_install "openssh autossh"
    pkg_try "wireguard-tools"

    sf_phase "Monitoring"
    pkg_install "htop"
    pkg_try "ctop"     # Docker-style containers monitor
    pip_install "glances"

    sf_phase "Aliasy DevOps"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: DevOps
alias k='kubectl'
alias tf='terraform'
alias dc='docker-compose'
alias g='git'
alias lg='lazygit'
alias glog='git log --oneline --graph --decorate --all'
alias gsync='git fetch --all && git pull --rebase'
alias ksys='kubectl get pods --all-namespaces'
alias fmt-json='python3 -m json.tool'
alias yml2json='python3 -c "import sys,yaml,json; json.dump(yaml.safe_load(sys.stdin), sys.stdout, indent=2)"'
EOF

    sf_ok "MODUŁ DevOps: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 9: Media / OSINT / Forensics
# ─────────────────────────────────────────────────────────────────────────────
install_media() {
    sf_step "MODUŁ: MEDIA / OSINT / FORENSICS"
    sf_phase "Media tools"

    pkg_install "ffmpeg"
    pkg_try "imagemagick"
    pkg_try "exiftool"

    sf_phase "Download tools"
    pkg_try "yt-dlp"
    pkg_try "aria2"

    sf_phase "OSINT Python stack"
    pip_install "yt-dlp shodan theHarvester" 2>/dev/null || true

    sf_phase "Sherlock — Hunt usernames across social networks"
    if [[ ! -d "$HOME/tools/sherlock" ]]; then
        sf_loading "Klonuję Sherlock..." &
        local pid=$!
        git clone --depth=1 -q https://github.com/sherlock-project/sherlock \
            "$HOME/tools/sherlock" >> "$LOG_FILE" 2>&1
        pip_install "-r $HOME/tools/sherlock/requirements.txt" 2>/dev/null
        sf_loading_done $pid "Sherlock zainstalowany"
    else
        sf_ok "Sherlock: już zainstalowany"
    fi

    sf_phase "Aliasy Media & OSINT"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: Media & OSINT
alias yt='yt-dlp'
alias yt-audio='yt-dlp -x --audio-format mp3'
alias yt-best='yt-dlp -f "bestvideo+bestaudio"'
alias exif='exiftool'
alias sherlock='python3 $HOME/tools/sherlock/sherlock'
alias ffprobe-info='ffprobe -v quiet -print_format json -show_format -show_streams'
EOF

    sf_ok "MODUŁ Media/OSINT: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 10: Databases
# ─────────────────────────────────────────────────────────────────────────────
install_db() {
    sf_step "MODUŁ: DATABASES"
    sf_phase "SQLite — wbudowany, bezplikowy"
    pkg_install "sqlite"

    sf_phase "MariaDB (MySQL compatible)"
    pkg_try "mariadb"
    if command -v mysqld_safe > /dev/null 2>&1; then
        sf_info "Inicjalizacja bazy MariaDB..."
        sf_try "mysqld_safe --initialize --datadir=\$HOME/.mariadb"
    fi

    sf_phase "Redis"
    pkg_try "redis"

    sf_phase "Python DB drivers"
    pip_install "sqlalchemy alembic psycopg2-binary pymysql redis motor"

    sf_phase "Narzędzia DB"
    pkg_try "pgcli"  # PostgreSQL client
    pkg_try "mycli"  # MySQL client z autouzupełnianiem

    sf_phase "Aliasy Database"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: Database
alias sql='sqlite3'
alias mysql-start='mysqld_safe --datadir=$HOME/.mariadb &'
alias mysql-stop='mysqladmin shutdown'
alias redis-start='redis-server &>/dev/null &'
alias redis-stop='redis-cli shutdown'
EOF

    sf_ok "MODUŁ Databases: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 11: IoT / Embedded
# ─────────────────────────────────────────────────────────────────────────────
install_iot() {
    sf_step "MODUŁ: IoT / EMBEDDED"
    sf_phase "Komunikacja szeregowa i protokoły"

    pkg_try "minicom"   # Serial console
    pkg_try "picocom"   # lightweight serial
    pkg_install "python"

    sf_phase "Python IoT/Embedded stack"
    pip_install "pyserial esptool platformio micropython-stubber"

    sf_phase "Protokoły sieciowe IoT"
    pip_install "paho-mqtt aiocoap"  # MQTT, CoAP

    sf_phase "Aliasy IoT"
    cat >> "$HOME/.zshrc" << 'EOF'

# SecFerro: IoT
alias esp-flash='esptool.py'
alias mqtt-sub='mosquitto_sub -h localhost'
alias mqtt-pub='mosquitto_pub -h localhost'
EOF

    sf_ok "MODUŁ IoT/Embedded: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# ██  MODUŁ 12: Game Dev / Scripting
# ─────────────────────────────────────────────────────────────────────────────
install_game() {
    sf_step "MODUŁ: GAME DEV / SCRIPTING"
    sf_phase "Silniki skryptowe"

    pkg_install "lua54 ruby perl"
    pkg_try "tcl"

    sf_phase "Python Game Dev"
    pip_install "pygame pyglet"

    sf_phase "Narzędzia do automatyzacji"
    pip_install "pyautogui keyboard mouse"

    sf_ok "MODUŁ GameDev/Scripting: kompletny"
}

# ─────────────────────────────────────────────────────────────────────────────
# KONFIGURACJA UI: Zsh + Oh-My-Zsh + Powerlevel10k + plugins
# ─────────────────────────────────────────────────────────────────────────────
setup_ui() {
    sf_step "ŚRODOWISKO: ZSH + OH-MY-ZSH + POWERLEVEL10K"

    sf_phase "Instalacja Oh-My-Zsh"
    if [[ ! -d "$HOME/.oh-my-zsh" ]]; then
        sf_loading "Pobieranie Oh-My-Zsh..." &
        local pid=$!
        curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh \
            -o /tmp/omz_install.sh >> "$LOG_FILE" 2>&1
        RUNZSH=no CHSH=no sh /tmp/omz_install.sh --unattended >> "$LOG_FILE" 2>&1
        rm -f /tmp/omz_install.sh
        sf_loading_done $pid "Oh-My-Zsh zainstalowany"
    else
        sf_ok "Oh-My-Zsh: już zainstalowany"
    fi

    local ZSH_CUSTOM="${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}"

    sf_phase "Plugin: zsh-autosuggestions"
    if [[ ! -d "${ZSH_CUSTOM}/plugins/zsh-autosuggestions" ]]; then
        sf_try "git clone --depth=1 -q \
            https://github.com/zsh-users/zsh-autosuggestions \
            ${ZSH_CUSTOM}/plugins/zsh-autosuggestions"
    else
        sf_ok "zsh-autosuggestions: już zainstalowany"
    fi

    sf_phase "Plugin: zsh-syntax-highlighting"
    if [[ ! -d "${ZSH_CUSTOM}/plugins/zsh-syntax-highlighting" ]]; then
        sf_try "git clone --depth=1 -q \
            https://github.com/zsh-users/zsh-syntax-highlighting \
            ${ZSH_CUSTOM}/plugins/zsh-syntax-highlighting"
    else
        sf_ok "zsh-syntax-highlighting: już zainstalowany"
    fi

    sf_phase "Plugin: zsh-history-substring-search"
    if [[ ! -d "${ZSH_CUSTOM}/plugins/zsh-history-substring-search" ]]; then
        sf_try "git clone --depth=1 -q \
            https://github.com/zsh-users/zsh-history-substring-search \
            ${ZSH_CUSTOM}/plugins/zsh-history-substring-search"
    else
        sf_ok "zsh-history-substring-search: już zainstalowany"
    fi

    sf_phase "Motyw: Powerlevel10k"
    if [[ ! -d "${ZSH_CUSTOM}/themes/powerlevel10k" ]]; then
        sf_loading "Pobieranie Powerlevel10k..." &
        local pid=$!
        git clone --depth=1 -q https://github.com/romkatv/powerlevel10k \
            "${ZSH_CUSTOM}/themes/powerlevel10k" >> "$LOG_FILE" 2>&1
        sf_loading_done $pid "Powerlevel10k zainstalowany"
    else
        sf_ok "Powerlevel10k: już zainstalowany"
    fi

    sf_phase "Generowanie .zshrc"
    [[ -f "$HOME/.zshrc" ]] && cp "$HOME/.zshrc" "$HOME/.zshrc.bak.$(date +%s)"

    cat > "$HOME/.zshrc" << 'ZSHRC_TEMPLATE'
# ──────────────────────────────────────────────────────
#  SECFERRO DIVISION SERIES — .zshrc
#  Anonymousik.is-a.dev  ·  github.com/Anonymousik
# ──────────────────────────────────────────────────────

export ZSH="$HOME/.oh-my-zsh"
ZSH_THEME="powerlevel10k/powerlevel10k"

# Plugins
plugins=(
    git
    zsh-autosuggestions
    zsh-syntax-highlighting
    zsh-history-substring-search
    colored-man-pages
    command-not-found
    sudo
    extract
)

source $ZSH/oh-my-zsh.sh

# p10k instant prompt
[[ -f ~/.p10k.zsh ]] && source ~/.p10k.zsh

# ── PATH ─────────────────────────────────────────────
export PATH="$HOME/.npm-global/bin:$HOME/.local/bin:$HOME/go/bin:$HOME/.cargo/bin:$PATH"

# ── HISTORIA ──────────────────────────────────────────
HISTSIZE=20000; SAVEHIST=20000
setopt HIST_IGNORE_DUPS SHARE_HISTORY HIST_REDUCE_BLANKS

# ── ŚRODOWISKO ────────────────────────────────────────
export EDITOR='nano'
export PAGER='less -R'
export LESS='-FRX'

# ── ALIASY SYSTEMOWE ──────────────────────────────────
alias ll='ls -lAhF --color=auto'
alias la='ls -A --color=auto'
alias l='ls -CF --color=auto'
alias ..='cd ..'
alias ...='cd ../..'
alias cls='clear'
alias q='exit'
alias c='clear'

# ── TERMUX ────────────────────────────────────────────
alias update='pkg update -y && pkg upgrade -y'
alias install='pkg install -y'
alias remove='pkg uninstall -y'

# ── SIEĆ ──────────────────────────────────────────────
alias myip='curl -s https://ipinfo.io/ip && echo'
alias myip-full='curl -s https://ipinfo.io/json'
alias ports='ss -tlnp'
alias dns-flush='kill -HUP $(pgrep -x dnsmasq) 2>/dev/null; echo "DNS flushed"'
alias http-serve='python3 -m http.server 8080'

# ── GIT ───────────────────────────────────────────────
alias gs='git status -sb'
alias ga='git add -A'
alias gc='git commit -m'
alias gp='git push'
alias gpl='git pull --rebase'
alias glog='git log --oneline --graph --decorate -20'

# ── UTILTY ────────────────────────────────────────────
alias j='jobs -l'
alias psg='ps aux | grep'
alias duh='du -sh * 2>/dev/null | sort -hr | head -20'
alias df='df -h'
alias free='free -h'
alias sizeof='du -sh'
alias json='python3 -m json.tool'
alias week='date +%V'
alias now='date +"%Y-%m-%d %H:%M:%S"'
alias ts='date +%s'

# ── SECFERRO MOTD ─────────────────────────────────────
_sf_motd() {
    echo -e "\033[0;36m\033[1m"
    echo "  ██████╗███████╗ ██████╗███████╗███████╗██████╗ ██████╗  ██████╗ "
    echo "  ██╔════╝██╔════╝██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔═══██╗"
    echo "  ███████╗█████╗  ██║     █████╗  █████╗  ██████╔╝██████╔╝██║   ██║"
    echo "  ╚════██║██╔══╝  ██║     ██╔══╝  ██╔══╝  ██╔══██╗██╔══██╗██║   ██║"
    echo "  ███████║███████╗╚██████╗██║     ███████╗██║  ██║██║  ██║╚██████╔╝"
    echo "  ╚══════╝╚══════╝ ╚═════╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝"
    echo -e "\033[0m\033[1;33m  SECFERRO DIVISION SERIES\033[0m  \033[2mv5.0.0 · IRONCLAD\033[0m"
    printf "  \033[2m%s  ·  $(hostname)  ·  \033[0;32m%s\033[0m\n" \
        "$(date '+%a %Y-%m-%d %H:%M')" "$(uname -r 2>/dev/null | cut -d- -f1 || echo Termux)"
    echo ""
}
_sf_motd

ZSHRC_TEMPLATE

    touch "$HOME/.hushlogin"
    sf_ok "Zsh + Oh-My-Zsh + Powerlevel10k + plugins: skonfigurowane"
}

# ─────────────────────────────────────────────────────────────────────────────
# KLUCZ SSH
# ─────────────────────────────────────────────────────────────────────────────
setup_ssh_key() {
    sf_step "BEZPIECZEŃSTWO: KLUCZ SSH"
    local key="$HOME/.ssh/id_ed25519"
    if [[ ! -f "$key" ]]; then
        mkdir -p "$HOME/.ssh" && chmod 700 "$HOME/.ssh"
        sf_info "Generowanie klucza SSH ed25519..."
        ssh-keygen -t ed25519 -C "secferro@$(hostname 2>/dev/null || echo termux)" \
            -f "$key" -N "" >> "$LOG_FILE" 2>&1 \
            && sf_ok "Klucz SSH wygenerowany: ${key}.pub" \
            || sf_warn "Generowanie klucza SSH nie powiodło się"
    else
        sf_ok "Klucz SSH: już istnieje (${key})"
    fi
}

# ─────────────────────────────────────────────────────────────────────────────
# ZAPIS KONFIGURACJI
# ─────────────────────────────────────────────────────────────────────────────
save_config() {
    {
        echo "# SecFerro Install Manifest"
        echo "# Generated: $(date)"
        echo "VERSION=$SCRIPT_VERSION"
        echo "CODENAME=$SCRIPT_CODENAME"
        for var in M_WEB M_ANDROID M_CYBER M_FULL M_TOR M_DOCKER \
                   M_DATA M_DEVOPS M_MEDIA M_DB M_IOT M_GAME; do
            echo "${var}=${!var}"
        done
        echo "ERRORS=$ERRORS"
    } > "$CONFIG_FILE"
    sf_ok "Manifest zapisany: $CONFIG_FILE"
}

# ─────────────────────────────────────────────────────────────────────────────
# DEINSTALACJA
# ─────────────────────────────────────────────────────────────────────────────
do_uninstall() {
    sf_step "DEINSTALACJA SECFERRO"
    sf_warn "Usuwa: Oh-My-Zsh, .zshrc, klucze konfiguracji, narzędzia z \$HOME/tools"
    read -rp "$(echo -e "  ${R}Kontynuować? [tak/N]: ${NC}")" confirm
    [[ "${confirm}" != "tak" ]] && { sf_info "Anulowano."; exit 0; }
    [[ -d "$HOME/.oh-my-zsh" ]] && rm -rf "$HOME/.oh-my-zsh" && sf_ok "Oh-My-Zsh usunięty"
    [[ -f "$HOME/.zshrc"    ]] && rm -f  "$HOME/.zshrc"    && sf_ok ".zshrc usunięty"
    [[ -f "$CONFIG_FILE"    ]] && rm -f  "$CONFIG_FILE"
    [[ -d "$HOME/tools"     ]] && rm -rf "$HOME/tools"     && sf_ok "Tools usunięte"
    sf_ok "Deinstalacja zakończona — zaloguj się ponownie"
    exit 0
}

# ─────────────────────────────────────────────────────────────────────────────
# POMOC
# ─────────────────────────────────────────────────────────────────────────────
print_help() {
    cat << EOF

${BLD}UŻYCIE:${NC}
  bash <(curl -sL anonymousik.is-a.dev/scripts/tmux_setup) [OPCJE]

${BLD}MODUŁY (--dev):${NC}
  ${C}WebDev${NC}     Node.js, Yarn, PHP, Python, Deno, TypeScript, Vite
  ${C}Android${NC}   OpenJDK 17, Gradle, Kotlin
  ${C}Cyber${NC}     nmap, sqlmap, hydra, nikto, scapy, pwntools, Metasploit
  ${C}Fullstack${NC} Rust, Go, C/C++, CMake, Lua
  ${C}Tor${NC}       Tor daemon, ProxyChains (dynamic), hardened torrc
  ${C}Docker${NC}    proot-distro, Ubuntu 22.04 LTS
  ${C}Data${NC}      numpy, pandas, sklearn, jupyter, HuggingFace, polars
  ${C}DevOps${NC}    kubectl, helm, ansible, terraform, gh CLI, jq, yq
  ${C}Media${NC}     ffmpeg, exiftool, yt-dlp, sherlock, OSINT stack
  ${C}DB${NC}        SQLite, MariaDB, Redis, SQLAlchemy, Alembic
  ${C}IoT${NC}       esptool, pyserial, MQTT, CoAP, platformio
  ${C}Game${NC}      Lua, Ruby, Perl, pygame, pyglet

${BLD}FLAGI:${NC}
  ${Y}--dev <moduły>${NC}   Moduły oddzielone przecinkiem
  ${Y}--dry-run${NC}        Symulacja bez instalacji
  ${Y}--no-ui${NC}          Pomiń konfigurację Zsh/Oh-My-Zsh
  ${Y}--verbose${NC}        Pełny output każdego polecenia
  ${Y}--uninstall${NC}      Usuń konfiguracje SecFerro
  ${Y}--version${NC}        Wyświetl wersję
  ${Y}--help${NC}           Ta wiadomość

${BLD}PRZYKŁADY:${NC}
  ${DM}# Pentester (Cyber + Tor + OSINT):${NC}
  bash <(curl -sL anonymousik.is-a.dev/scripts/tmux_setup) --dev Cyber,Tor,Media

  ${DM}# Fullstack Developer:${NC}
  bash <(curl -sL anonymousik.is-a.dev/scripts/tmux_setup) --dev WebDev,DB,DevOps

  ${DM}# Data Scientist:${NC}
  bash <(curl -sL anonymousik.is-a.dev/scripts/tmux_setup) --dev Data,DB,DevOps

  ${DM}# Pełna instalacja:${NC}
  bash <(curl -sL anonymousik.is-a.dev/scripts/tmux_setup) --dev WebDev,Android,Cyber,Fullstack,Tor,Docker,Data,DevOps,Media,DB

EOF
}

# ─────────────────────────────────────────────────────────────────────────────
# PARSER ARGUMENTÓW
# ─────────────────────────────────────────────────────────────────────────────
parse_args() {
    while [[ "$#" -gt 0 ]]; do
        case $1 in
            --dev)
                [[ -z "${2:-}" ]] && { sf_error "--dev wymaga listy modułów"; exit 1; }
                local OLD_IFS="$IFS"; IFS=',' read -ra MODS <<< "$2"; IFS="$OLD_IFS"
                for m in "${MODS[@]}"; do
                    case $m in
                        WebDev)    M_WEB=true ;;
                        Android)   M_ANDROID=true ;;
                        Cyber)     M_CYBER=true ;;
                        Fullstack) M_FULL=true ;;
                        Tor)       M_TOR=true ;;
                        Docker)    M_DOCKER=true ;;
                        Data)      M_DATA=true ;;
                        DevOps)    M_DEVOPS=true ;;
                        Media)     M_MEDIA=true ;;
                        DB)        M_DB=true ;;
                        IoT)       M_IOT=true ;;
                        Game)      M_GAME=true ;;
                        *)         sf_warn "Nieznany moduł: '$m' — dostępne: $(print_help | grep -oP '(?<=\${C\})\w+')" ;;
                    esac
                done
                shift ;;
            --dry-run)   DRY_RUN=true ;;
            --no-ui)     SKIP_UI=true ;;
            --verbose)   VERBOSE=true ;;
            --uninstall) DO_UNINSTALL=true ;;
            --version)   echo "SecFerro v${SCRIPT_VERSION} (${SCRIPT_CODENAME})"; exit 0 ;;
            --help|-h)   print_banner; print_help; exit 0 ;;
            *)           sf_error "Nieznana flaga: '$1' — użyj --help"; exit 1 ;;
        esac
        shift
    done
}

# ─────────────────────────────────────────────────────────────────────────────
# MENU INTERAKTYWNE
# ─────────────────────────────────────────────────────────────────────────────
interactive_menu() {
    echo -e "${BLD}  WYBIERZ MODUŁY INSTALACJI:${NC}"
    echo -e "  ${DM}(kilka opcji: 1,3,5 · wszystko: all)${NC}\n"

    echo -e "  ${C} 1)${NC} WebDev     — Node.js, PHP, Python, Deno, TypeScript, Vite"
    echo -e "  ${C} 2)${NC} Android    — OpenJDK 17, Gradle, Kotlin"
    echo -e "  ${C} 3)${NC} Cyber      — nmap, sqlmap, hydra, nikto, scapy, pwntools"
    echo -e "  ${C} 4)${NC} Fullstack  — Rust, Go, C/C++, CMake, Lua"
    echo -e "  ${C} 5)${NC} Tor+Proxy  — Tor daemon, ProxyChains, hardened torrc"
    echo -e "  ${C} 6)${NC} Docker     — proot-distro + Ubuntu 22.04 LTS"
    echo -e "  ${C} 7)${NC} Data/ML    — numpy, pandas, sklearn, jupyter, HuggingFace"
    echo -e "  ${C} 8)${NC} DevOps     — kubectl, helm, ansible, gh CLI, jq/yq"
    echo -e "  ${C} 9)${NC} Media/OSINT— ffmpeg, yt-dlp, exiftool, sherlock"
    echo -e "  ${C}10)${NC} Database   — SQLite, MariaDB, Redis, SQLAlchemy"
    echo -e "  ${C}11)${NC} IoT        — esptool, pyserial, MQTT, platformio"
    echo -e "  ${C}12)${NC} Game/Script— Lua, Ruby, pygame"
    echo ""
    echo -e "  ${Y}all)${NC} Wszystko   — Pełna instalacja (1–12)"
    echo -e "  ${R}  0)${NC} Wyjście"
    echo ""

    read -rp "$(echo -e "  ${BLD}Wybór: ${NC}")" raw
    local OLD_IFS="$IFS"; IFS=',' read -ra choices <<< "$raw"; IFS="$OLD_IFS"

    for c in "${choices[@]}"; do
        c="${c// /}"  # trim spaces
        case $c in
            1)   M_WEB=true ;;
            2)   M_ANDROID=true ;;
            3)   M_CYBER=true ;;
            4)   M_FULL=true ;;
            5)   M_TOR=true ;;
            6)   M_DOCKER=true ;;
            7)   M_DATA=true ;;
            8)   M_DEVOPS=true ;;
            9)   M_MEDIA=true ;;
            10)  M_DB=true ;;
            11)  M_IOT=true ;;
            12)  M_GAME=true ;;
            all) M_WEB=true; M_ANDROID=true; M_CYBER=true; M_FULL=true
                 M_TOR=true; M_DOCKER=true; M_DATA=true; M_DEVOPS=true
                 M_MEDIA=true; M_DB=true; M_IOT=true; M_GAME=true ;;
            0)   sf_info "Wychodzę."; exit 0 ;;
            *)   sf_warn "Nieznany wybór: '$c'" ;;
        esac
    done
    echo ""
}

# ─────────────────────────────────────────────────────────────────────────────
# PODSUMOWANIE
# ─────────────────────────────────────────────────────────────────────────────
print_summary() {
    local installed=()
    [[ $M_WEB    == true ]] && installed+=("WebDev")
    [[ $M_ANDROID== true ]] && installed+=("Android")
    [[ $M_CYBER  == true ]] && installed+=("CyberSec")
    [[ $M_FULL   == true ]] && installed+=("Fullstack")
    [[ $M_TOR    == true ]] && installed+=("Tor+ProxyChains")
    [[ $M_DOCKER == true ]] && installed+=("proot-distro/Ubuntu")
    [[ $M_DATA   == true ]] && installed+=("Data/ML")
    [[ $M_DEVOPS == true ]] && installed+=("DevOps/Cloud")
    [[ $M_MEDIA  == true ]] && installed+=("Media/OSINT")
    [[ $M_DB     == true ]] && installed+=("Databases")
    [[ $M_IOT    == true ]] && installed+=("IoT/Embedded")
    [[ $M_GAME   == true ]] && installed+=("Game/Scripting")

    echo ""
    echo -e "${C}${BLD}"
    echo    "  ╔══════════════════════════════════════════════════╗"
    echo    "  ║                                                  ║"
    echo    "  ║     SECFERRO DIVISION — INSTALACJA KOMPLETNA     ║"
    echo    "  ║                                                  ║"
    echo -e "  ╚══════════════════════════════════════════════════╝${NC}"
    echo ""
    echo -e "  ${BLD}Zainstalowane moduły:${NC}"
    for m in "${installed[@]}"; do
        echo -e "    ${G}✓${NC} $m"
    done
    if [[ $ERRORS -gt 0 ]]; then
        echo ""
        echo -e "  ${Y}Ostrzeżenia: $ERRORS błędy niekrityyczne${NC}"
        echo -e "  ${DM}Szczegóły: $LOG_FILE${NC}"
    fi
    echo ""
    echo -e "  ${BLD}Następne kroki:${NC}"
    echo -e "    ${Y}exec zsh${NC}         → Wejdź do nowej powłoki z MOTD"
    echo -e "    ${Y}p10k configure${NC}   → Skonfiguruj motyw Powerlevel10k"
    [[ $M_TOR    == true ]] && echo -e "    ${Y}tor-start${NC}        → Uruchom Tor daemon"
    [[ $M_DOCKER == true ]] && echo -e "    ${Y}ubuntu${NC}           → Wejdź do Ubuntu"
    [[ $M_DATA   == true ]] && echo -e "    ${Y}jnb${NC}              → Jupyter Notebook"
    [[ $M_MEDIA  == true ]] && echo -e "    ${Y}sherlock <nick>${NC}  → Hunt username OSINT"
    echo ""
    echo -e "  ${DM}Manifest instalacji: $CONFIG_FILE${NC}"
    echo -e "  ${DM}Log: $LOG_FILE${NC}"
    echo ""
    echo -e "  ${P}${DM}SECFERRO DIVISION SERIES · Anonymousik.is-a.dev${NC}"
    echo ""
}

# ─────────────────────────────────────────────────────────────────────────────
# MAIN
# ─────────────────────────────────────────────────────────────────────────────
main() {
    # Inicjalizacja logu
    mkdir -p "$(dirname "$LOG_FILE")" 2>/dev/null
    echo "# SecFerro Install Log v${SCRIPT_VERSION} — $(date)" > "$LOG_FILE"

    print_banner

    # Argumenty
    [[ $# -gt 0 ]] && parse_args "$@"

    # Deinstalacja
    [[ $DO_UNINSTALL == true ]] && do_uninstall

    # Menu jeśli brak modułów
    local any=false
    for v in M_WEB M_ANDROID M_CYBER M_FULL M_TOR M_DOCKER \
             M_DATA M_DEVOPS M_MEDIA M_DB M_IOT M_GAME; do
        [[ "${!v}" == true ]] && any=true && break
    done
    [[ $any == false ]] && interactive_menu

    # Dry-run info
    [[ $DRY_RUN == true ]] && sf_warn "TRYB DRY-RUN — żadne pakiety nie zostaną zainstalowane"

    # ── PRE-FLIGHT ──────────────────────────────────────────────────────────
    preflight

    # ── INSTALACJA ──────────────────────────────────────────────────────────
    setup_base

    [[ $M_WEB     == true ]] && install_web
    [[ $M_ANDROID == true ]] && install_android
    [[ $M_CYBER   == true ]] && install_cyber
    [[ $M_FULL    == true ]] && install_fullstack
    [[ $M_TOR     == true ]] && install_tor
    [[ $M_DOCKER  == true ]] && install_docker
    [[ $M_DATA    == true ]] && install_data
    [[ $M_DEVOPS  == true ]] && install_devops
    [[ $M_MEDIA   == true ]] && install_media
    [[ $M_DB      == true ]] && install_db
    [[ $M_IOT     == true ]] && install_iot
    [[ $M_GAME    == true ]] && install_game

    # ── UI ──────────────────────────────────────────────────────────────────
    [[ $SKIP_UI == false ]] && setup_ui

    # ── SSH KEY ─────────────────────────────────────────────────────────────
    setup_ssh_key

    # ── MANIFEST ────────────────────────────────────────────────────────────
    [[ $DRY_RUN == false ]] && save_config

    print_summary
}

main "$@"