#!/usr/bin/env bash
# silom — Silo (S3, форк MinIO) + Caddy Manager (AlmaLinux 8/9)
#
#   silom install [--template FILE] [--rpm FILE]  полная установка: Silo + Caddy + firewall
#   silom firewall                                только firewall на nftables: сброс всех
#                                                 правил и создание заново в интерактиве
#   silom trust                                   заново добавить корневой сертификат Caddy
#                                                 в доверенные (фикс "SSL certificate problem")
#   silom update                                  обновление Silo/mcli из GitHub Releases и Caddy из COPR
#   silom self-install                            только установить silom в /usr/local/bin
#
# --template FILE  — файл-образец /etc/default/silo: берутся только активные строки,
#                    серверо-зависимые параметры запрашиваются интерактивно.
# --rpm FILE       — локальный RPM Silo вместо загрузки последнего релиза.
# --debug          — подробный вывод (например, загруженные правила nftables).
# GITHUB_TOKEN     — (env, опционально) токен для GitHub API, если упёрлись в rate limit.

set -Eeuo pipefail

INSTANCE="mnogoweb"
STATE_DIR="/etc/silom"
LEGACY_STATE_DIR="/etc/vgwm"
CLIENTS_FILE="${STATE_DIR}/clients.list"

SILO_ENV="/etc/default/silo"
SILO_SERVICE="silo"
SILO_REPO="pgsty/silo"
MCLI_REPOS=(pgsty/silo pgsty/mc)
SILO_API="127.0.0.1:9000"
SILO_CONSOLE="127.0.0.1:9001"

CADDYFILE="/etc/caddy/Caddyfile"
CADDY_CERT_DIR="/etc/caddy/certs"
CADDY_ROOT_CA="/var/lib/caddy/.local/share/caddy/pki/authorities/local/root.crt"
CA_ANCHOR="/etc/pki/ca-trust/source/anchors/caddy-${INSTANCE}-root.crt"
CA_EXPORT="${STATE_DIR}/ca-root.crt"

ADMIN_IPS=(94.250.251.190 46.161.40.8)          # SSH + 80/443
MON_IPS=(212.237.218.213 37.228.116.152)        # Zabbix + Beszel
SSH_PORT=9999
ZABBIX_PORT=10050
BESZEL_PORT=45876

# заполняются в configure_silo
REGION="" DOMAIN="" ACCESS="" SECRET="" TLS_MODE=""

# ---------- helpers ----------
log()  { echo -e "\e[32m[+]\e[0m $*"; }
warn() { echo -e "\e[33m[!]\e[0m $*" >&2; }
die()  { echo -e "\e[31m[x]\e[0m $*" >&2; exit 1; }

ask() {  # ask "Вопрос" "default" -> stdout
    local prompt="$1" def="${2:-}" ans
    if [[ -n "$def" ]]; then read -rp "$prompt [$def]: " ans; echo "${ans:-$def}"
    else read -rp "$prompt: " ans; echo "$ans"; fi
}
ask_secret() {
    local prompt="$1" def="${2:-}" ans
    read -rsp "$prompt${def:+ [оставить текущий]}: " ans; echo >&2
    echo "${ans:-$def}"
}
yes_no() { local a; read -rp "$1 [y/N]: " a; [[ "$a" =~ ^[YyДд]$ ]]; }

valid_ip() {  # IPv4/IPv6 с опциональным /маска
    python3 - "$1" <<'PY' 2>/dev/null
import ipaddress, sys
ipaddress.ip_network(sys.argv[1], strict=False)
PY
}
ip_family() { [[ "$1" == *:* ]] && echo ipv6 || echo ipv4; }

need_root() { [[ $EUID -eq 0 ]] || die "Запускать от root"; }

get_kv() { grep -E "^[[:space:]]*$1=" "$2" 2>/dev/null | tail -1 | cut -d= -f2- | tr -d "\"'" || true; }

state_get() { cat "${STATE_DIR}/$1" 2>/dev/null || true; }
state_set() { mkdir -p "$STATE_DIR"; echo "$2" >"${STATE_DIR}/$1"; }

gen_key() { python3 -c "import secrets,string,sys;a=string.ascii_letters+string.digits;print(''.join(secrets.choice(a) for _ in range(int(sys.argv[1]))))" "$1"; }

migrate_state() {  # перенос списка клиентов и FTP-портов от vgwm
    if [[ -d "$LEGACY_STATE_DIR" && ! -d "$STATE_DIR" ]]; then
        cp -a "$LEGACY_STATE_DIR" "$STATE_DIR"
        log "Настройки firewall перенесены из $LEGACY_STATE_DIR"
    fi
    mkdir -p "$STATE_DIR"
}

load_state() {  # для режимов без install
    DOMAIN="$(state_get domain)"
    TLS_MODE="$(state_get tls_mode)"
    REGION="$(get_kv MINIO_SITE_REGION "$SILO_ENV")"
}

# ---------- RPM из GitHub Releases ----------
arch_suffix() {
    case "$(uname -m)" in
        x86_64)  echo 'x86_64' ;;
        aarch64) echo 'aarch64' ;;
        *) die "Неподдерживаемая архитектура: $(uname -m)" ;;
    esac
}

gh_latest_rpm() {  # gh_latest_rpm REPO NAME_REGEX -> путь к rpm (stdout) или код 1
    local repo="$1" re="$2" json urls url tag tmp hdr=()
    command -v curl >/dev/null || dnf -y install curl >&2
    [[ -n "${GITHUB_TOKEN:-}" ]] && hdr=(-H "Authorization: Bearer ${GITHUB_TOKEN}")
    json="$(curl -fsSL "${hdr[@]}" "https://api.github.com/repos/${repo}/releases/latest")" || return 1
    tag="$(grep -oP '"tag_name":\s*"\K[^"]+' <<<"$json" | head -1 || true)"
    urls="$(grep -oP '"browser_download_url":\s*"\K[^"]+' <<<"$json" || true)"
    url="$(grep -E "${re}\.$(arch_suffix)\.rpm$" <<<"$urls" | head -1 || true)"
    [[ -n "$url" ]] || return 1

    tmp="$(mktemp -d)"
    log "Скачиваю ${repo} ${tag}: $(basename "$url")" >&2
    curl -fL --retry 3 -o "$tmp/$(basename "$url")" "$url" >&2 || return 1
    if grep -qxF "${url}.sha256sum" <<<"$urls"; then
        curl -fsSL --retry 3 -o "$tmp/$(basename "$url").sha256sum" "${url}.sha256sum" >&2
        (cd "$tmp" && sha256sum --check --quiet "$(basename "$url").sha256sum") >&2 \
            || die "Контрольная сумма $(basename "$url") не совпала"
        log "SHA-256 проверен" >&2
    else
        warn "В релизе нет .sha256sum для $(basename "$url") — проверка пропущена"
    fi
    echo "$tmp/$(basename "$url")"
}

download_silo_rpm() {
    gh_latest_rpm "$SILO_REPO" '/silo-[0-9][^/]*' \
        || die "Не удалось получить RPM Silo из ${SILO_REPO} для $(uname -m)"
}

download_mcli_rpm() {  # -> путь или код 1
    local repo
    for repo in "${MCLI_REPOS[@]}"; do
        gh_latest_rpm "$repo" '/mcli[-_][0-9][^/]*' && return 0
    done
    return 1
}

install_rpm() {
    local rpm="$1"
    [[ -f "$rpm" ]] || die "RPM не найден: $rpm"
    dnf -y install "$rpm"
}

install_silo() {
    local rpm="${1:-}" cleanup=0
    if [[ -z "$rpm" ]]; then rpm="$(download_silo_rpm)"; cleanup=1; fi
    install_rpm "$rpm"
    (( cleanup )) && rm -rf "$(dirname "$rpm")"
    id silo >/dev/null 2>&1 || die "После установки нет пользователя silo — проверьте пакет"
    log "Silo: $(rpm -q silo)"

    if command -v mcli >/dev/null; then
        log "mcli уже установлен"
    elif rpm="$(download_mcli_rpm)"; then
        install_rpm "$rpm"; rm -rf "$(dirname "$rpm")"
    else
        warn "RPM mcli не найден в релизах — поставьте вручную: https://silo.pigsty.io/download/#client"
    fi
}

stop_versitygw() {
    local units
    units="$(systemctl list-units --all --plain --no-legend 'versitygw@*' 2>/dev/null | awk '{print $1}' || true)"
    [[ -n "$units" ]] || return 0
    warn "Найден VersityGW: $(echo $units)"
    if yes_no "Остановить и отключить VersityGW (он занимает 443)?"; then
        systemctl disable --now $units || true
        log "VersityGW остановлен. Данные в его каталоге не тронуты."
    else
        warn "VersityGW оставлен — Caddy не сможет занять порт 443"
    fi
}

# ---------- Silo ----------
MANAGED_KEYS=(MINIO_VOLUMES MINIO_OPTS MINIO_ROOT_USER MINIO_ROOT_PASSWORD
              MINIO_SERVER_URL MINIO_BROWSER_REDIRECT_URL MINIO_SITE_REGION)

configure_silo() {
    local template="${1:-}" tmp old re data def_reg
    tmp="$(mktemp)"
    if [[ -n "$template" ]]; then
        [[ -f "$template" ]] || die "Шаблон не найден: $template"
        grep -Ev '^[[:space:]]*(#|$)' "$template" | sed -E 's/[[:space:]]+$//' >"$tmp" || true
        log "Из шаблона взято активных параметров: $(wc -l <"$tmp")"
    fi
    # управляемые ключи всегда пишем сами
    re="^[[:space:]]*($(IFS='|'; echo "${MANAGED_KEYS[*]}"))="
    grep -Ev "$re" "$tmp" >"$tmp.x" || true; mv "$tmp.x" "$tmp"

    old="$SILO_ENV"; [[ -f "$old" ]] || old=/dev/null

    echo "--- Серверо-зависимые параметры ---"
    def_reg="$(get_kv MINIO_SITE_REGION "$old")"
    REGION="$(ask "Регион (MINIO_SITE_REGION), напр. ru1" "$def_reg")"
    [[ "$REGION" =~ ^[a-z0-9-]+$ ]] || die "Некорректный регион: $REGION"

    DOMAIN="$(ask "Базовый домен (консоль)" "$(state_get domain | grep . || echo "bs-${REGION}.mnogoweb.com")")"
    [[ "$DOMAIN" =~ ^[a-z0-9.-]+$ ]] || die "Некорректный домен: $DOMAIN"

    data="$(get_kv MINIO_VOLUMES "$old")"
    data="$(ask "Каталог данных (MINIO_VOLUMES)" "${data:-/data/silo}")"
    [[ "$data" == /* ]] || die "Нужен абсолютный путь: $data"
    if [[ -d "$data" && -n "$(ls -A "$data" 2>/dev/null)" && ! -d "$data/.minio.sys" ]]; then
        warn "Каталог $data не пуст и не похож на хранилище Silo/MinIO."
        warn "Silo не подхватит существующие файлы как объекты — их нужно переносить через mcli mirror/rclone."
        yes_no "Всё равно использовать $data?" || die "Отменено"
    fi

    ACCESS="$(get_kv MINIO_ROOT_USER "$old")"
    SECRET="$(get_kv MINIO_ROOT_PASSWORD "$old")"
    if [[ -z "$ACCESS" || -z "$SECRET" ]] || yes_no "Сгенерировать новые root-ключи?"; then
        if yes_no "Ввести root-ключи вручную (иначе — сгенерировать)?"; then
            ACCESS="$(ask "Root user (access key)" "")"
            SECRET="$(ask_secret "Root password (secret key)" "")"
        else
            ACCESS="$(gen_key 16)"; SECRET="$(gen_key 32)"
        fi
    fi
    (( ${#ACCESS} >= 3 )) || die "Root user — минимум 3 символа"
    (( ${#SECRET} >= 8 )) || die "Root password — минимум 8 символов"
    [[ "$ACCESS$SECRET" != *[\"\\\'[:space:]]* ]] || die "В ключах нельзя использовать кавычки, \\ и пробелы"

    cat >>"$tmp" <<EOF
# --- управляется silom, правки этих строк будут перезаписаны ---
MINIO_VOLUMES="${data}"
MINIO_OPTS="--address ${SILO_API} --console-address ${SILO_CONSOLE}"
MINIO_ROOT_USER="${ACCESS}"
MINIO_ROOT_PASSWORD="${SECRET}"
MINIO_SITE_REGION="${REGION}"
MINIO_SERVER_URL="https://s3.${DOMAIN}"
MINIO_BROWSER_REDIRECT_URL="https://${DOMAIN}"
EOF

    [[ -f "$SILO_ENV" ]] && cp -a "$SILO_ENV" "${SILO_ENV}.bak.$(date +%F_%H%M%S)"
    install -m 0640 -o root -g silo "$tmp" "$SILO_ENV"
    rm -f "$tmp"

    mkdir -p "$data"
    chown silo:silo "$data"; chmod 0750 "$data"

    state_set domain "$DOMAIN"
    log "Конфиг записан: $SILO_ENV"
}

ensure_hosts() {  # консоль Silo ходит в API по внешнему имени — резолвим его локально
    sed -i '/[[:space:]]# silom$/d' /etc/hosts
    echo "127.0.0.1 s3.${DOMAIN} ${DOMAIN} # silom" >>/etc/hosts
    log "/etc/hosts: s3.${DOMAIN}, ${DOMAIN} -> 127.0.0.1"
}

start_silo() {
    systemctl daemon-reload
    systemctl enable "$SILO_SERVICE" >/dev/null 2>&1
    systemctl restart "$SILO_SERVICE" \
        || { journalctl -u "$SILO_SERVICE" -n 40 --no-pager; die "Silo не стартовал"; }
    curl -fsS -o /dev/null "http://${SILO_API}/minio/health/live" \
        && log "Silo запущен ($(silo --version 2>/dev/null | head -1 || rpm -q silo))" \
        || { journalctl -u "$SILO_SERVICE" -n 40 --no-pager; die "Silo не отвечает на ${SILO_API}"; }
}

setup_mcli_alias() {
    command -v mcli >/dev/null || return 0
    mcli alias set local "http://${SILO_API}" "$ACCESS" "$SECRET" >/dev/null \
        && log "mcli: алиас 'local' настроен (mcli admin info local)" \
        || warn "Не удалось настроить алиас mcli"
}

# ---------- Caddy ----------
install_caddy() {
    if rpm -q caddy >/dev/null 2>&1; then log "Caddy: $(rpm -q caddy)"; return; fi
    dnf -y install dnf-plugins-core
    dnf -y copr enable @caddy/caddy
    dnf -y install caddy
    log "Caddy: $(rpm -q caddy)"
}

check_cert_host() {  # check_cert_host CERT HOST
    openssl x509 -in "$1" -noout -checkhost "$2" 2>/dev/null | grep -q 'does match' \
        || warn "Сертификат $1 НЕ покрывает $2 (wildcard *.example.com не покрывает a.b.example.com)"
}

configure_caddy() {
    local def mode global="" tls_line="" src email
    def="$(state_get tls_mode)"
    echo "--- TLS для Caddy ---"
    echo "  1) internal — свой CA Caddy (сервер закрыт снаружи; клиентам нужен корневой сертификат)"
    echo "  2) cert     — свои файлы сертификата и ключа"
    echo "  3) acme     — Let's Encrypt (нужен доступ к 80/443 из интернета)"
    mode="$(ask "Режим" "${def:-internal}")"
    case "$mode" in 1) mode=internal ;; 2) mode=cert ;; 3) mode=acme ;; esac

    case "$mode" in
        internal)
            global="skip_install_trust"
            tls_line="tls internal"
            ;;
        cert)
            install -d -m 0750 -o root -g caddy "$CADDY_CERT_DIR"
            for f in fullchain.pem privkey.pem; do
                if [[ -f "$CADDY_CERT_DIR/$f" ]]; then
                    src="$(ask "$f уже есть. Путь к новому файлу (пусто — оставить)" "")"
                else
                    src="$(ask "Путь к файлу $f (будет скопирован в $CADDY_CERT_DIR)" "")"
                fi
                if [[ -n "$src" ]]; then
                    [[ -f "$src" ]] || die "Файл не найден: $src"
                    install -m 0640 -o root -g caddy "$src" "$CADDY_CERT_DIR/$f"
                fi
                [[ -f "$CADDY_CERT_DIR/$f" ]] || die "Нет $CADDY_CERT_DIR/$f"
            done
            check_cert_host "$CADDY_CERT_DIR/fullchain.pem" "s3.${DOMAIN}"
            check_cert_host "$CADDY_CERT_DIR/fullchain.pem" "${DOMAIN}"
            tls_line="tls ${CADDY_CERT_DIR}/fullchain.pem ${CADDY_CERT_DIR}/privkey.pem"
            ;;
        acme)
            email="$(ask "E-mail для Let's Encrypt" "$(state_get acme_email)")"
            [[ -n "$email" ]] && { global="email ${email}"; state_set acme_email "$email"; }
            ;;
        *) die "Неизвестный режим: $mode" ;;
    esac
    TLS_MODE="$mode"
    state_set tls_mode "$mode"

    [[ -f "$CADDYFILE" ]] && cp -a "$CADDYFILE" "${CADDYFILE}.bak.$(date +%F_%H%M%S)"
    cat >"$CADDYFILE" <<EOF
# Сгенерировано silom $(date '+%F %T'). Ручные правки будут перезаписаны.
{
	${global:-admin localhost:2019}
}

# S3 API
s3.${DOMAIN} {
	${tls_line}
	reverse_proxy ${SILO_API}
}

# Консоль Silo
${DOMAIN} {
	${tls_line}
	reverse_proxy ${SILO_CONSOLE}
}
EOF
    caddy validate --config "$CADDYFILE" --adapter caddyfile >/dev/null 2>&1 \
        || { caddy validate --config "$CADDYFILE" --adapter caddyfile; die "Ошибка в $CADDYFILE"; }

    if command -v getenforce >/dev/null && [[ "$(getenforce)" != "Disabled" ]]; then
        setsebool -P httpd_can_network_connect 1 && log "SELinux: httpd_can_network_connect=on"
    fi

    local busy
    busy="$(ss -ltnpH '( sport = :443 or sport = :80 )' 2>/dev/null | grep -v '"caddy"' || true)"
    [[ -z "$busy" ]] || { echo "$busy"; die "Порты 80/443 заняты другим процессом"; }

    systemctl enable caddy >/dev/null 2>&1
    systemctl restart caddy || { journalctl -u caddy -n 40 --no-pager; die "Caddy не стартовал"; }
    log "Caddy запущен (TLS: $mode)"
}

# ---------- доверие к CA Caddy ----------
trust_caddy_ca() {
    local i
    for i in $(seq 1 30); do [[ -f "$CADDY_ROOT_CA" ]] && break; sleep 1; done
    [[ -f "$CADDY_ROOT_CA" ]] || die "Корневой сертификат Caddy не появился: $CADDY_ROOT_CA (journalctl -u caddy)"
    install -m 0644 "$CADDY_ROOT_CA" "$CA_ANCHOR"
    update-ca-trust
    install -m 0644 "$CADDY_ROOT_CA" "$CA_EXPORT"
    log "CA Caddy добавлен в доверенные системы: $CA_ANCHOR"
}

print_client_ca_help() {
    cat <<EOF

    Корневой сертификат для клиентов: $CA_EXPORT
      AlmaLinux/RHEL:  cp ca-root.crt /etc/pki/ca-trust/source/anchors/ && update-ca-trust
      Debian/Ubuntu:   cp ca-root.crt /usr/local/share/ca-certificates/ca-root.crt && update-ca-certificates
      PHP (AWS SDK):   'http' => ['verify' => '/path/to/ca-root.crt']
      Браузер:         импорт в доверенные корневые ОС (Firefox — в свои настройки)
EOF
}

verify_chain() {  # проверка: Caddy -> Silo по внешнему имени с проверкой сертификата
    if curl -fsS -o /dev/null --resolve "s3.${DOMAIN}:443:127.0.0.1" "https://s3.${DOMAIN}/minio/health/live"; then
        log "https://s3.${DOMAIN} — OK (сертификат проверен)"
    else
        warn "https://s3.${DOMAIN} через Caddy не отвечает или сертификат не принят"
        [[ "$TLS_MODE" == "internal" ]] && warn "Попробуйте: silom trust"
        return 1
    fi
}

trust_mode() {
    load_state
    [[ -n "$DOMAIN" ]] || die "Не найден домен в $STATE_DIR — сначала silom install"
    [[ "$TLS_MODE" == "internal" ]] || warn "Текущий режим TLS: ${TLS_MODE:-неизвестен}, CA Caddy нужен только для internal"
    trust_caddy_ca
    systemctl restart "$SILO_SERVICE" && log "Silo перезапущен (перечитал доверенные сертификаты)"
    verify_chain || true
    print_client_ca_help
}

# ---------- firewall (nftables) ----------
read_ip_list() {  # интерактивный ввод списка IP -> CLIENTS[]
    local def="" input
    [[ -f "$CLIENTS_FILE" ]] && def="$(tr '\n' ' ' <"$CLIENTS_FILE" | sed 's/ $//')"
    echo "Список IP/подсетей клиентов для 80/443 и FTP (через пробел или запятую)."
    input="$(ask "IP клиентов" "$def")"
    CLIENTS=()
    for ip in ${input//,/ }; do
        valid_ip "$ip" && CLIENTS+=("$ip") || warn "Пропущен некорректный адрес: $ip"
    done
    mkdir -p "$STATE_DIR"
    printf '%s\n' "${CLIENTS[@]}" >"$CLIENTS_FILE"
}

NFT_RULES="/etc/nftables/silom.nft"
NFT_MAIN="/etc/sysconfig/nftables.conf"
ROLLBACK_SEC=60

# элементы set'а для одного семейства: nft_elems ipv4|ipv6 IP...
nft_elems() {
    local fam="$1"; shift
    local out=() ip
    for ip in "$@"; do [[ "$(ip_family "$ip")" == "$fam" ]] && out+=("$ip"); done
    (( ${#out[@]} )) && { local IFS=,; echo "elements = { ${out[*]} };"; }
}

gen_ruleset() {  # gen_ruleset PASV -> stdout
    local pasv="$1"
    cat <<EOF
#!/usr/sbin/nft -f
# Сгенерировано silom $(date '+%F %T'). Ручные правки будут перезаписаны.
flush ruleset

table inet silom {
    set admin4   { type ipv4_addr; flags interval; $(nft_elems ipv4 "${ADMIN_IPS[@]}") }
    set admin6   { type ipv6_addr; flags interval; $(nft_elems ipv6 "${ADMIN_IPS[@]}") }
    set clients4 { type ipv4_addr; flags interval; $(nft_elems ipv4 "${CLIENTS[@]}") }
    set clients6 { type ipv6_addr; flags interval; $(nft_elems ipv6 "${CLIENTS[@]}") }
    set mon4     { type ipv4_addr; flags interval; $(nft_elems ipv4 "${MON_IPS[@]}") }
    set mon6     { type ipv6_addr; flags interval; $(nft_elems ipv6 "${MON_IPS[@]}") }

    chain input {
        type filter hook input priority filter; policy drop;

        iif lo accept
        ct state established,related accept
        ct state invalid drop

        # IPv6 не работает без Neighbor Discovery
        icmpv6 type { nd-neighbor-solicit, nd-neighbor-advert, nd-router-advert, nd-router-solicit } ip6 hoplimit 255 accept

        # SSH
        tcp dport $SSH_PORT ip  saddr @admin4 accept
        tcp dport $SSH_PORT ip6 saddr @admin6 accept

        # HTTP/HTTPS (Caddy): админы + клиенты
        tcp dport { 80, 443 } ip  saddr @admin4   accept
        tcp dport { 80, 443 } ip6 saddr @admin6   accept
        tcp dport { 80, 443 } ip  saddr @clients4 accept
        tcp dport { 80, 443 } ip6 saddr @clients6 accept

        # FTP (control + passive)
        tcp dport { 21, $pasv } ip  saddr @clients4 accept
        tcp dport { 21, $pasv } ip6 saddr @clients6 accept

        # Zabbix-agent, Beszel-agent
        tcp dport { $ZABBIX_PORT, $BESZEL_PORT } ip  saddr @mon4 accept
        tcp dport { $ZABBIX_PORT, $BESZEL_PORT } ip6 saddr @mon6 accept
    }

    chain forward {
        type filter hook forward priority filter; policy drop;
    }

    chain output {
        type filter hook output priority filter; policy accept;
    }
}
EOF
}

ensure_nftables() {
    rpm -q nftables >/dev/null 2>&1 || dnf -y install nftables || die "Не удалось установить nftables"

    # всё, что тоже управляет netfilter, должно быть выключено
    local svc
    for svc in firewalld iptables ip6tables ufw; do
        if systemctl is-active --quiet "$svc" 2>/dev/null || systemctl is-enabled --quiet "$svc" 2>/dev/null; then
            warn "Найден конкурирующий сервис: $svc"
            yes_no "Остановить, отключить и замаскировать $svc?" || die "Конфликт с $svc — прервано"
            systemctl disable --now "$svc" >/dev/null 2>&1 || true
            systemctl mask "$svc" >/dev/null 2>&1 || true
        fi
    done

    [[ "$(systemctl is-enabled nftables 2>/dev/null)" == "masked" ]] && systemctl unmask nftables
    command -v nft >/dev/null || die "nft не найден"
    log "nftables $(nft --version | awk '{print $2}')"
}

apply_with_rollback() {  # apply_with_rollback FILE
    local new="$1" backup
    backup="$(mktemp)"
    nft list ruleset >"$backup"

    nft -c -f "$new" || { rm -f "$backup"; die "Ошибка синтаксиса правил: $new"; }
    nft -f "$new"    || { rm -f "$backup"; die "Не удалось применить правила"; }

    if [[ -t 0 && -n "${SSH_CONNECTION:-}" ]]; then
        warn "Правила применены. Откройте НОВУЮ SSH-сессию и проверьте доступ."
        local ans=""
        read -r -t "$ROLLBACK_SEC" -p "Введите 'ok' в течение ${ROLLBACK_SEC} c, иначе откат: " ans || true
        echo
        if [[ "$ans" != "ok" ]]; then
            { echo "flush ruleset"; cat "$backup"; } | nft -f -
            rm -f "$backup"
            die "Подтверждения нет — правила откатаны, изменения не сохранены"
        fi
    fi
    rm -f "$backup"
}

persist_ruleset() {
    install -d -m 0755 "$(dirname "$NFT_RULES")"
    install -m 0600 "$1" "$NFT_RULES"
    [[ -f "$NFT_MAIN" ]] && ! grep -qx "include \"$NFT_RULES\"" "$NFT_MAIN" \
        && cp -a "$NFT_MAIN" "${NFT_MAIN}.bak.$(date +%F_%H%M%S)"
    cat >"$NFT_MAIN" <<EOF
# Управляется silom. Все правила — в $NFT_RULES
include "$NFT_RULES"
EOF
    systemctl enable nftables >/dev/null 2>&1
    systemctl restart nftables || { journalctl -u nftables -n 20 --no-pager; die "nftables.service не стартовал"; }
}

configure_firewall() {
    ensure_nftables

    read_ip_list
    local pasv; pasv="$(ask "Диапазон пассивных портов FTP" "$(cat "$STATE_DIR/ftp_pasv" 2>/dev/null || echo 30000-31000)")"
    [[ "$pasv" =~ ^[0-9]+-[0-9]+$ ]] || die "Неверный диапазон: $pasv"
    echo "$pasv" >"$STATE_DIR/ftp_pasv"

    # защита от потери доступа
    local me="${SSH_CLIENT%% *}"
    if [[ -n "$me" ]] && ! printf '%s\n' "${ADMIN_IPS[@]}" | grep -qx "$me"; then
        warn "Ваш текущий IP $me НЕ входит в список SSH ($SSH_PORT): ${ADMIN_IPS[*]}"
        yes_no "Продолжить?" || die "Отменено"
    fi
    ss -ltnH "sport = :$SSH_PORT" 2>/dev/null | grep -q . \
        || warn "Никто не слушает порт $SSH_PORT — после применения SSH будет недоступен"

    local tmp; tmp="$(mktemp)"
    gen_ruleset "$pasv" >"$tmp"

    log "Сброс всех правил и применение нового набора"
    apply_with_rollback "$tmp"
    persist_ruleset "$tmp"
    rm -f "$tmp"

    log "Firewall применён и сохранён в $NFT_RULES"
    if (( DEBUG )); then
        echo "--- [debug] загруженные правила ---"
        nft list table inet silom
    fi
}

# ---------- update ----------
update_rpm() {  # update_rpm NAME RPM_PATH -> 0 если обновлено
    local name="$1" rpm="$2" cur new
    cur="$(rpm -q "$name" 2>/dev/null || echo 'не установлен')"
    new="$(rpm -qp --qf '%{NAME}-%{VERSION}-%{RELEASE}.%{ARCH}' "$rpm")"
    log "$name: установлено $cur | доступно $new"
    if [[ "$cur" == "$new" ]]; then rm -rf "$(dirname "$rpm")"; return 1; fi
    dnf -y install "$rpm"
    rm -rf "$(dirname "$rpm")"
}

update_all() {
    local rpm
    if update_rpm silo "$(download_silo_rpm)"; then
        systemctl daemon-reload
        systemctl restart "$SILO_SERVICE" \
            || { journalctl -u "$SILO_SERVICE" -n 30 --no-pager; die "Silo не стартовал после обновления"; }
        log "Silo обновлён и запущен"
    else
        log "Silo уже актуален"
    fi

    if rpm="$(download_mcli_rpm)"; then
        update_rpm mcli "$rpm" || log "mcli уже актуален"
    else
        warn "RPM mcli в релизах не найден — пропуск"
    fi

    if rpm -q caddy >/dev/null 2>&1; then
        dnf -y upgrade caddy
        systemctl reload caddy || systemctl restart caddy
        log "Caddy: $(rpm -q caddy)"
    fi

    load_state
    [[ -n "$DOMAIN" ]] && { verify_chain || true; }
}

# ---------- self-install ----------
SELF_BIN="/usr/local/bin/silom"

self_install() {
    local self; self="$(readlink -f "$0" 2>/dev/null || true)"
    [[ -f "$self" && "$self" != "$SELF_BIN" ]] || return 0   # уже установлен или запуск через pipe
    if [[ -f "$SELF_BIN" ]] && cmp -s "$self" "$SELF_BIN"; then return 0; fi
    local action="Установлен"; [[ -f "$SELF_BIN" ]] && action="Обновлён"
    install -m 0755 -o root -g root "$self" "$SELF_BIN"
    log "$action silom → $SELF_BIN (дальше можно запускать просто: silom <режим>)"
}

usage() { sed -n '2,16p' "$SELF_BIN" 2>/dev/null || sed -n '2,16p' "$0"; }

# ---------- install ----------
install_all() {
    local template="$1" rpm="$2"
    stop_versitygw
    install_silo "$rpm"
    configure_silo "$template"
    ensure_hosts
    install_caddy
    configure_caddy
    [[ "$TLS_MODE" == "internal" ]] && trust_caddy_ca
    start_silo            # после trust: Silo читает доверенные CA при старте
    setup_mcli_alias
    verify_chain || true
    configure_firewall

    log "Готово"
    echo "    Регион:      $REGION"
    echo "    S3 API:      https://s3.${DOMAIN}   (в PHP: use_path_style_endpoint => true)"
    echo "    Консоль:     https://${DOMAIN}"
    echo "    Access key:  $ACCESS"
    echo "    Secret key:  $SECRET   <- сохраните"
    [[ "$TLS_MODE" == "internal" ]] && print_client_ca_help
    return 0
}

# ---------- main ----------
DEBUG=0

main() {
    # --debug допускается в любом месте командной строки
    local args=() a
    for a in "$@"; do [[ "$a" == "--debug" ]] && DEBUG=1 || args+=("$a"); done
    set -- "${args[@]+"${args[@]}"}"

    need_root
    self_install
    migrate_state
    local mode="${1:-}"; shift || true
    local template="" rpm=""
    while [[ $# -gt 0 ]]; do
        case "$1" in
            --template) template="${2:-}"; shift 2 ;;
            --rpm)      rpm="${2:-}"; shift 2 ;;
            *) die "Неизвестный параметр: $1" ;;
        esac
    done

    case "$mode" in
        install)                   install_all "$template" "$rpm" ;;
        firewall|firewall-only|fw) configure_firewall ;;
        trust)                     trust_mode ;;
        update)                    update_all ;;
        self-install)              log "silom установлен в $SELF_BIN" ;;
        ""|help|-h|--help)         usage ;;
        *) usage; exit 1 ;;
    esac
}
main "$@"
