#!/bin/bash
# =========================================================================
# deploy_gpg_keys.sh —— 把 AGIROS 仓库签名公钥分发到所有版本目录
#
# 用途（在仓库服务器上执行）:
#   1. 扫描 REPO_ROOT 下所有 ubuntuXXXXlts/YYYY 版本目录
#   2. 确定"权威公钥"：
#      a) 如果本地 GPG keyring 里存在 AGIROS 签名私钥 → 从私钥导出公钥
#      b) 否则从仓库中已经存在的 agiros.gpg 里抓一份（作为模板）
#      c) 如果仓库中也没有 → 可选自动生成新密钥（需 --generate）
#   3. 把统一的公钥复制到每个版本目录，替换缺失或内容不一致的
#
# 用法:
#   # 最常用（自动从本地 keyring 导出公钥，分发到所有版本目录）
#   sudo ./deploy_gpg_keys.sh --repo-root /srv/repo/debrepo/agiros
#   sudo ./deploy_gpg_keys.sh --repo-root . --all --yes     --export-private /root/agiros-repo-private.key
#   # 指定密钥 UID（当本地有多把 AGIROS 密钥时）
#   sudo ./deploy_gpg_keys.sh --repo-root /srv/repo/debrepo/agiros \
#       --key-uid "agiros-repo-signing-key <lihongyu@agiros.edu.cn>"
#
#   # 首次部署：本地无密钥、仓库也没有，自动生成新密钥
#   sudo ./deploy_gpg_keys.sh --repo-root /srv/repo/debrepo/agiros --generate \
#       --key-name "AGIROS Repository Signing" \
#       --key-email "repo-signing@agiros.org.cn"
#
#   # dry-run（只打印将要做什么，不实际写文件）
#   ./deploy_gpg_keys.sh --repo-root /srv/repo/debrepo/agiros --dry-run
# =========================================================================

set -euo pipefail

# ---------- 默认值 ----------
REPO_ROOT=""                # 必须通过 --repo-root 指定
KEY_UID=""                  # 指定 GPG 密钥 UID（可选）
KEY_NAME="AGIROS Repository Signing"
KEY_EMAIL="signing@agiros.org.cn"
KEY_LENGTH=4096
GENERATE_NEW=0
DRY_RUN=0
EXPORT_PRIVATE="/root/agiros-repo-private.key"          # 可选：把私钥导出到指定文件（务必离线备份）
DO_SIGN=1                  # 是否用私钥重新签名 Release / InRelease
GEN_INDEX=1                # 是否给缺失 dists 的目录生成索引
REBUILD_RELEASE=1          # 是否用现有 Packages 重建 Release（修正错误的哈希路径）
ASSUME_YES=1               # 跳过确认

# ---------- 彩色 ----------
R='\033[31m'; G='\033[32m'; Y='\033[33m'; C='\033[0m'

usage() {
    cat <<EOF
用法: $0 --repo-root <PATH> [选项]

必须指定:
  --repo-root <PATH>       AGIROS debrepo 根目录，包含 ubuntu2204lts/ ubuntu2404lts/ 等子目录

可选:
  --key-uid <UID>          指定使用哪个 GPG 密钥的 UID 或指纹；默认自动匹配含 "agiros" 的签名密钥
  --generate               生成一把新的 RSA 签名密钥（优先于复用仓库旧公钥）
  --key-name <NAME>        --generate 时的 Name-Real（默认: $KEY_NAME）
  --key-email <EMAIL>      --generate 时的 Name-Email（默认: $KEY_EMAIL）
  --key-length <N>         --generate 时的 RSA 长度（默认: $KEY_LENGTH）
  --export-private <FILE>  把私钥导出到 FILE（权限 600），用于离线备份
  --sign                   用私钥重新签名所有 dists/*/Release（生成 Release.gpg 和 InRelease）
  --gen-index              给没有 dists 索引的版本目录，从 pool/ 生成 Packages 和 Release
  --rebuild-release        用现有 Packages 重建 Release，修正哈希路径带 "codename/" 前缀的旧文件
  --all                    等价于 --generate --gen-index --rebuild-release --sign
  --yes                    跳过交互确认
  --dry-run                只打印将要做什么，不实际写文件
  -h | --help              显示本帮助

示例:
  # 一键完成：生成密钥 → 导出私钥 → 补索引 → 重签 → 分发公钥
  sudo $0 --repo-root /srv/repo/debrepo/agiros --all \
      --export-private /root/agiros-repo-private.key
  # 已有私钥，只做重签 + 分发
  sudo $0 --repo-root /srv/repo/debrepo/agiros --sign
  # 只分发公钥
  sudo $0 --repo-root /srv/repo/debrepo/agiros
  # 只做体检（不写文件）
  sudo $0 --repo-root /srv/repo/debrepo/agiros --all --dry-run
EOF
    exit 0
}

# =========================================================================
# 参数解析
# =========================================================================
while [[ $# -gt 0 ]]; do
    case "$1" in
        --repo-root)    REPO_ROOT="${2:?--repo-root 需要路径参数}"; shift 2 ;;
        --key-uid)      KEY_UID="${2:?--key-uid 需要 UID}"; shift 2 ;;
        --generate)     GENERATE_NEW=1; shift ;;
        --key-name)     KEY_NAME="${2:?}"; shift 2 ;;
        --key-email)    KEY_EMAIL="${2:?}"; shift 2 ;;
        --key-length)   KEY_LENGTH="${2:?}"; shift 2 ;;
        --export-private) EXPORT_PRIVATE="${2:?--export-private 需要文件路径}"; shift 2 ;;
        --sign)         DO_SIGN=1; shift ;;
        --gen-index)    GEN_INDEX=1; shift ;;
        --rebuild-release) REBUILD_RELEASE=1; shift ;;
        --all)          GENERATE_NEW=1; GEN_INDEX=1; REBUILD_RELEASE=1; DO_SIGN=1; shift ;;
        --yes)          ASSUME_YES=1; shift ;;
        --dry-run)      DRY_RUN=1; shift ;;
        -h|--help)      usage ;;
        *)              echo -e "${R}未知参数: $1${C}" >&2; usage ;;
    esac
done

if [[ -z "$REPO_ROOT" ]]; then
    echo -e "${R}❌ 必须指定 --repo-root${C}" >&2
    usage
fi
REPO_ROOT="${REPO_ROOT%/}"
if [[ ! -d "$REPO_ROOT" ]]; then
    echo -e "${R}❌ 仓库根目录不存在: $REPO_ROOT${C}" >&2
    exit 1
fi
REPO_ROOT=$(cd "$REPO_ROOT" && pwd)

if ! command -v gpg &>/dev/null; then
    echo -e "${R}❌ 需要先安装 gnupg：apt-get install -y gnupg${C}" >&2
    exit 1
fi

# 索引生成后端：优先 apt-ftparchive，没有则用同目录的 gen_index.py（openEuler 等 rpm 系统）
SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
GEN_INDEX_PY="$SCRIPT_DIR/gen_index.py"
APT_FTPARCHIVE=""
if command -v apt-ftparchive &>/dev/null; then
    APT_FTPARCHIVE="apt-ftparchive"
fi

if [[ "$GEN_INDEX" == "1" ]]; then
    if [[ -z "$APT_FTPARCHIVE" ]] && { [[ ! -f "$GEN_INDEX_PY" ]] || ! command -v python3 &>/dev/null; }; then
        echo -e "${R}❌ --gen-index 需要 apt-ftparchive 或 python3 + $GEN_INDEX_PY${C}" >&2
        echo "   Debian/Ubuntu: apt-get install -y apt-utils" >&2
        echo "   openEuler/CentOS: 把 gen_index.py 与本脚本放在同一目录（只需 python3）" >&2
        exit 1
    fi
    if [[ -z "$APT_FTPARCHIVE" ]]; then
        echo "未找到 apt-ftparchive，使用内置 Python 实现生成索引：$GEN_INDEX_PY"
    fi
fi

# 让 Web 服务器可读：mktemp 生成的文件是 600，直接 mv 会导致 Apache 403
chmod_pub() {
    local f
    for f in "$@"; do
        [[ -e "$f" ]] || continue
        chmod 644 "$f" 2>/dev/null || true
        if [[ "$(id -u)" == "0" ]]; then
            chown --reference="$(dirname "$f")" "$f" 2>/dev/null || true
        fi
    done
}

# 生成 Packages（vdir, pool 相对路径, 输出文件）
gen_packages_index() {
    local vdir="$1" pool_rel="$2" out="$3"
    if [[ -n "$APT_FTPARCHIVE" ]]; then
        ( cd "$vdir" && "$APT_FTPARCHIVE" packages "$pool_rel" > "$out" )
    else
        python3 "$GEN_INDEX_PY" packages --root "$vdir" --pool "$pool_rel" --out "$out"
    fi
}

# 列出某个 Release 目录下已存在 Packages 的架构（amd64 arm64 ...）
release_archs() {
    local rel_dir="$1" p a archs=""
    for p in "$rel_dir"/main/binary-*/Packages; do
        [[ -f "$p" ]] || continue
        a=$(basename "$(dirname "$p")")
        a=${a#binary-}
        archs+="${archs:+ }$a"
    done
    echo "$archs"
}

# 生成 Release（vdir, codename, 版本号, 架构列表, 输出文件）
gen_release_index() {
    local vdir="$1" codename="$2" version="$3" archs="$4" out="$5"
    if [[ -n "$APT_FTPARCHIVE" ]]; then
        "$APT_FTPARCHIVE" \
            -o APT::FTPArchive::Release::Origin="AGIROS Repository" \
            -o APT::FTPArchive::Release::Label="AGIROS" \
            -o APT::FTPArchive::Release::Suite="$codename" \
            -o APT::FTPArchive::Release::Codename="$codename" \
            -o APT::FTPArchive::Release::Version="$version" \
            -o APT::FTPArchive::Release::Architectures="$archs" \
            -o APT::FTPArchive::Release::Components="main" \
            -o APT::FTPArchive::Release::Description="AGIROS 软件仓库" \
            release "$vdir/dists/$codename" > "$out"
    else
        python3 "$GEN_INDEX_PY" release --root "$vdir" --codename "$codename" \
            --version "$version" --archs "$archs" --out "$out"
    fi
}

# =========================================================================
# 1. 扫描仓库中的版本目录
# =========================================================================
discover_version_dirs() {
    local dirs=()
    local ubuntu_dir ver_dir ver_name
    for ubuntu_dir in "$REPO_ROOT"/ubuntu*/; do
        [[ -d "$ubuntu_dir" ]] || continue
        for ver_dir in "$ubuntu_dir"*/; do
            [[ -d "$ver_dir" ]] || continue
            ver_name=$(basename "$ver_dir")
            # 只保留全数字目录（2506/2612），排除 3-party / 3rd / 3-party-bak 等非版本目录
            if [[ "$ver_name" =~ ^[0-9]+$ ]]; then
                dirs+=("${ver_dir%/}")
            fi
        done
    done
    printf '%s\n' "${dirs[@]}" | sort -u
}

echo "仓库根目录: $REPO_ROOT"
echo "扫描版本目录 ..."
mapfile -t VERSION_DIRS < <(discover_version_dirs)

if [[ ${#VERSION_DIRS[@]} -eq 0 ]]; then
    echo -e "${R}❌ 在 $REPO_ROOT 下未找到任何 ubuntuXXXXlts/YYYY 目录。${C}" >&2
    exit 1
fi
echo "发现 ${#VERSION_DIRS[@]} 个版本目录:"
for d in "${VERSION_DIRS[@]}"; do
    echo "   $(realpath --relative-to="$REPO_ROOT" "$d")"
done

# =========================================================================
# 2. 确定权威公钥
#    优先级: 本地 GPG 私钥 > 仓库已有 agiros.gpg > 自动生成（需 --generate）
# =========================================================================

# ---- 2a. 尝试从本地 GPG keyring 导出 ----
find_local_key() {
    local uid="${KEY_UID:-}"
    if [[ -n "$uid" ]]; then
        gpg --list-secret-keys --with-colons "$uid" 2>/dev/null \
            | awk -F: '/^sec:/{s=1} s && /^fpr:/ {print $10; exit}'
        return
    fi
    # 未指定 UID，自动找含 "agiros" 的签名私钥
    gpg --list-secret-keys --with-colons 2>/dev/null \
        | awk -F: '/^sec:/{s=1} s && /^fpr:/ {print $10; s=0}' \
        | while read -r fpr; do
              local info
              info=$(gpg --list-keys --with-colons "$fpr" 2>/dev/null)
              if echo "$info" | grep -i "agiros" >/dev/null; then
                  echo "$fpr"
                  return 0
              fi
          done
}

echo ""
echo "查找本地 GPG 签名密钥 ..."
LOCAL_FPR=$(find_local_key || true)

AUTH_PUB=""   # 权威公钥文件（导出到临时位置）
AUTH_SRC=""   # 公钥来源说明

# 生成新密钥（只在策略 A/B 都不满足，或显式 --generate 时执行）
generate_new_key() {
    echo "将自动生成一把 RSA${KEY_LENGTH} 的签名密钥 ..."
    local tmp_batch
    tmp_batch=$(mktemp /tmp/agiros-genkey-XXXXXX)
    cat > "$tmp_batch" <<EOF
%no-protection
Key-Type: RSA
Key-Length: $KEY_LENGTH
Key-Usage: sign
Name-Real: $KEY_NAME
Name-Email: $KEY_EMAIL
Expire-Date: 0
%commit
%echo generated
EOF
    gpg --batch --gen-key "$tmp_batch"
    rm -f "$tmp_batch"

    LOCAL_FPR=$(gpg --list-secret-keys --with-colons "$KEY_EMAIL" 2>/dev/null \
        | awk -F: '/^sec:/{s=1} s && /^fpr:/ {print $10; exit}')
    AUTH_PUB=$(mktemp /tmp/agiros-pub-XXXXXX.gpg)
    gpg --batch --yes --export --output "$AUTH_PUB" "$LOCAL_FPR"
    AUTH_SRC="新生成的密钥 (指纹 $LOCAL_FPR, UID: $KEY_NAME <$KEY_EMAIL>)"
    echo -e "${G}✅ 新密钥已生成，私钥位于 ${GNUPGHOME:-$HOME/.gnupg}${C}"
}

if [[ -n "$LOCAL_FPR" ]]; then
    # ---- 策略 A：本地 keyring 已有私钥 ----
    echo -e "${G}✅ 在本地 GPG keyring 中找到密钥: $LOCAL_FPR${C}"
    AUTH_PUB=$(mktemp /tmp/agiros-pub-XXXXXX.gpg)
    gpg --batch --yes --export --output "$AUTH_PUB" "$LOCAL_FPR"
    AUTH_SRC="本地私钥 (指纹 $LOCAL_FPR)"

elif [[ "$GENERATE_NEW" == "1" ]]; then
    # ---- 策略 B：显式 --generate，强制生成新密钥 ----
    # 注意：--generate 的优先级高于"复用仓库已有 agiros.gpg"，
    #       否则一旦仓库里存在旧公钥，--generate 会被静默忽略。
    echo -e "${Y}⚠ 已指定 --generate，将生成全新密钥（不复用仓库旧公钥）${C}"
    if [[ "$DRY_RUN" == "1" ]]; then
        # dry-run 不写 keyring，避免产生无法撤销的副作用
        echo -e "${G}[DRY-RUN] 将生成新密钥（本次不实际生成）${C}"
        AUTH_SRC="新生成的密钥（DRY-RUN，尚未生成）"
        AUTH_PUB=""
    else
        generate_new_key
    fi

else
    echo -e "${Y}⚠ 本地 GPG keyring 中没有 AGIROS 签名私钥。${C}"

    # ---- 策略 C：复用仓库里已有的 agiros.gpg ----
    echo "尝试从仓库中已有的 agiros.gpg 获取公钥 ..."
    for d in "${VERSION_DIRS[@]}"; do
        cand="$d/agiros.gpg"
        if [[ -f "$cand" ]]; then
            AUTH_PUB="$cand"
            AUTH_SRC="仓库已有公钥: $(basename "$(dirname "$d")")/$(basename "$d")/agiros.gpg"
            echo -e "${G}✅ 找到仓库已有公钥: $AUTH_SRC${C}"
            break
        fi
    done

    if [[ -z "$AUTH_PUB" ]]; then
        echo -e "${R}❌ 既没有本地私钥、仓库里也没有 agiros.gpg，无法确定权威公钥。${C}" >&2
        echo "   请先导入 AGIROS 签名私钥，或使用 --generate 自动生成一把新密钥。" >&2
        exit 1
    fi
fi

echo ""
echo "权威公钥来源: $AUTH_SRC"
AUTH_MD5=""
if [[ -n "$AUTH_PUB" ]]; then
    echo "权威公钥文件: $AUTH_PUB"
    echo "公钥指纹:"
    gpg --list-keys --with-colons "$AUTH_PUB" 2>/dev/null \
        | awk -F: '/^pub:/ {print "  指纹: " $5} /^uid:/ {print "  UID : " $10}' \
        || gpg --show-keys "$AUTH_PUB" 2>/dev/null | sed 's/^/  /'
    AUTH_MD5=$(md5sum "$AUTH_PUB" | awk '{print $1}')
    echo "公钥 MD5: $AUTH_MD5"
else
    echo "公钥指纹: (dry-run 不生成密钥，无法提前计算)"
fi

# 可选：导出私钥，用于离线备份
if [[ -n "$EXPORT_PRIVATE" ]]; then
    if [[ -z "$LOCAL_FPR" ]]; then
        if [[ "$DRY_RUN" == "1" && "$GENERATE_NEW" == "1" ]]; then
            echo -e "${G}[DRY-RUN] 将在生成密钥后导出私钥到 $EXPORT_PRIVATE${C}"
        else
            echo -e "${Y}⚠ 本地没有私钥，跳过 --export-private${C}" >&2
        fi
    elif [[ "$DRY_RUN" == "1" ]]; then
        echo -e "${G}[DRY-RUN] 将把私钥导出到 $EXPORT_PRIVATE${C}"
    else
        mkdir -p "$(dirname "$EXPORT_PRIVATE")"
        gpg --batch --yes --armor --export-secret-keys --output "$EXPORT_PRIVATE" "$LOCAL_FPR"
        chmod 600 "$EXPORT_PRIVATE"
        echo -e "${G}✅ 私钥已导出: $EXPORT_PRIVATE（权限 600，请立即离线备份并删除服务器上的副本）${C}"
    fi
fi

# =========================================================================
# 3. 生成缺失索引（--gen-index）
#    仓库结构: <ver>/pool/<x86_64|aarch64|riscv64>/**/*.deb
#              <ver>/dists/<codename>/main/binary-<arch>/Packages(.gz)
#              <ver>/dists/<codename>/Release
# =========================================================================
ubuntu_to_codename() {
    case "$1" in
        ubuntu2204lts) echo "jammy" ;;
        ubuntu2404lts) echo "noble" ;;
        ubuntu2604lts) echo "resolute" ;;
        *)             echo "" ;;
    esac
}

pool_arch_to_debarch() {
    case "$1" in
        x86_64|amd64)  echo "amd64" ;;
        aarch64|arm64) echo "arm64" ;;
        riscv64)       echo "riscv64" ;;
        *)             echo "" ;;
    esac
}

# 从 dists/<codename>/main/binary-*/Packages 反推架构列表并生成 Release
release_from_existing_packages() {
    local rel_dir="$1"
    local archs=() p arch
    for p in "$rel_dir"/main/binary-*/Packages; do
        [[ -f "$p" ]] || continue
        arch=$(basename "$(dirname "$p")")
        archs+=("${arch#binary-}")
    done
    [[ ${#archs[@]} -gt 0 ]] || return 1

    local vdir codename tmp
    vdir=$(cd "$rel_dir/../.." && pwd)
    codename=$(basename "$rel_dir")
    tmp=$(mktemp /tmp/agiros-release-XXXXXX)
    gen_release_index "$vdir" "$codename" "$(basename "$vdir")" "${archs[*]}" "$tmp"
    mv -f "$tmp" "$rel_dir/Release"
    chmod_pub "$rel_dir/Release"
}

# 从 pool/ 生成完整 dists 索引（Packages + Release）
generate_index_for() {
    local vdir="$1"
    local ubuntu_name codename pool_arch deb_arch arch_dir idx archs=()
    ubuntu_name=$(basename "$(dirname "$vdir")")
    codename=$(ubuntu_to_codename "$ubuntu_name")

    if [[ -z "$codename" ]]; then
        echo -e "  ${Y}[跳过]${C} 无法从 $ubuntu_name 推断 Ubuntu 代号"
        return 1
    fi
    if [[ ! -d "$vdir/pool" ]]; then
        echo -e "  ${Y}[跳过]${C} 没有 pool/ 目录"
        return 1
    fi

    for arch_dir in "$vdir"/pool/*/; do
        [[ -d "$arch_dir" ]] || continue
        pool_arch=$(basename "$arch_dir")
        deb_arch=$(pool_arch_to_debarch "$pool_arch")
        [[ -n "$deb_arch" ]] || continue

        idx="$vdir/dists/$codename/main/binary-$deb_arch"
        mkdir -p "$idx"
        gen_packages_index "$vdir" "pool/$pool_arch" "$idx/Packages"
        gzip -9 -kf "$idx/Packages"
        chmod_pub "$idx/Packages" "$idx/Packages.gz"
        archs+=("$deb_arch")
        echo "  + binary-$deb_arch/Packages ($(grep -c '^Package:' "$idx/Packages" || true) 个包)"
    done

    if [[ ${#archs[@]} -eq 0 ]]; then
        echo -e "  ${Y}[跳过]${C} pool/ 下没有可识别的架构目录"
        return 1
    fi

    local tmp
    tmp=$(mktemp /tmp/agiros-release-XXXXXX)
    gen_release_index "$vdir" "$codename" "$(basename "$vdir")" "${archs[*]}" "$tmp"
    mv -f "$tmp" "$vdir/dists/$codename/Release"
    chmod_pub "$vdir/dists/$codename/Release"
    echo "  + Release (架构: ${archs[*]})"
}

# =========================================================================
# 4. 签名 dists/*/Release
# =========================================================================
sign_release_dir() {
    local rel_dir="$1"
    [[ -f "$rel_dir/Release" ]] || return 1
    gpg --batch --yes --armor --detach-sign -u "$LOCAL_FPR" \
        -o "$rel_dir/Release.gpg" "$rel_dir/Release"
    gpg --batch --yes --clearsign -u "$LOCAL_FPR" \
        -o "$rel_dir/InRelease" "$rel_dir/Release"
    chmod_pub "$rel_dir/Release" "$rel_dir/Release.gpg" "$rel_dir/InRelease"
}

if [[ "$DO_SIGN" == "1" || "$GEN_INDEX" == "1" || "$REBUILD_RELEASE" == "1" ]]; then
    if [[ -z "$LOCAL_FPR" ]] && ! [[ "$DRY_RUN" == "1" && "$GENERATE_NEW" == "1" ]]; then
        echo -e "${R}❌ --sign / --gen-index 需要本地私钥，但当前 keyring 中没有可用密钥。${C}" >&2
        echo "   请先导入私钥，或使用 --all（内含 --generate）。" >&2
        exit 1
    fi

    if [[ "$ASSUME_YES" != "1" && "$DRY_RUN" != "1" ]]; then
        echo ""
        echo -e "${Y}即将修改 ${#VERSION_DIRS[@]} 个版本目录下的索引与签名文件。${C}"
        read -r -p "确认继续？(y/N) " ans </dev/tty 2>/dev/null || ans=""
        [[ "$ans" =~ ^[Yy]$ ]] || { echo "已取消"; exit 1; }
    fi

    echo ""
    echo "处理 dists 索引与签名 ..."
    signed=0; generated=0; skipped=0; planned=0

    for d in "${VERSION_DIRS[@]}"; do
        rel_name=$(realpath --relative-to="$REPO_ROOT" "$d")
        echo ""
        echo "[$rel_name]"

        # 情况 1：整个 dists 目录都不存在 → 需要从 pool 生成
        if [[ ! -d "$d/dists" ]]; then
            if [[ "$GEN_INDEX" != "1" ]]; then
                echo -e "  ${Y}[缺少索引]${C} 加 --gen-index 可从 pool/ 自动生成"
                skipped=$((skipped+1))
                continue
            fi
            echo -e "  ${G}生成索引${C}"
            if [[ "$DRY_RUN" == "1" ]]; then
                echo "  [DRY-RUN] 将从 pool/ 生成 dists 索引"
                planned=$((planned+1))
                continue
            fi
            if ! generate_index_for "$d"; then
                skipped=$((skipped+1))
                continue
            fi
            generated=$((generated+1))
        fi

        # 情况 2：dists 存在，逐代号目录处理
        for rel_dir in "$d"/dists/*/; do
            [[ -d "$rel_dir" ]] || continue
            codename=$(basename "$rel_dir")

            if [[ ! -f "$rel_dir/Release" ]]; then
                if [[ "$GEN_INDEX" != "1" ]]; then
                    echo -e "  ${Y}[缺少 Release]${C} $codename"
                    skipped=$((skipped+1))
                    continue
                fi
                if [[ "$DRY_RUN" == "1" ]]; then
                    echo "  [DRY-RUN] 将生成 $codename/Release"
                    planned=$((planned+1))
                elif release_from_existing_packages "$rel_dir"; then
                    echo -e "  ${G}+${C} $codename/Release"
                    generated=$((generated+1))
                else
                    echo -e "  ${Y}[跳过]${C} $codename 下没有 Packages，无法生成 Release"
                    skipped=$((skipped+1))
                    continue
                fi
            fi

            # 重建 Release：修正旧文件里 "codename/xxx/Packages" 这种错误路径
            if [[ "$REBUILD_RELEASE" == "1" ]]; then
                rebuild_archs=$(release_archs "$rel_dir")
                if [[ -z "$rebuild_archs" ]]; then
                    echo -e "  ${Y}[跳过]${C} $codename 下没有 Packages，无法重建 Release"
                    skipped=$((skipped+1))
                elif [[ "$DRY_RUN" == "1" ]]; then
                    echo "  [DRY-RUN] 将重建 $codename/Release（架构: $rebuild_archs）"
                    planned=$((planned+1))
                else
                    rebuild_tmp=$(mktemp /tmp/agiros-release-XXXXXX)
                    gen_release_index "$d" "$codename" "$(basename "$d")" "$rebuild_archs" "$rebuild_tmp"
                    mv -f "$rebuild_tmp" "$rel_dir/Release"
                    chmod_pub "$rel_dir/Release"
                    echo -e "  ${G}+${C} 已重建 $codename/Release（架构: $rebuild_archs）"
                    generated=$((generated+1))
                fi
            fi

            if [[ "$DO_SIGN" != "1" ]]; then
                continue
            fi
            if [[ "$DRY_RUN" == "1" ]]; then
                echo "  [DRY-RUN] 将签名 $codename/Release → Release.gpg + InRelease"
                planned=$((planned+1))
            elif sign_release_dir "$rel_dir"; then
                echo -e "  ${G}✅${C} 已签名 $codename/Release"
                signed=$((signed+1))
            else
                echo -e "  ${R}❌${C} 签名失败: $codename"
                skipped=$((skipped+1))
            fi
        done
    done

    echo ""
    echo "----------- 索引/签名小结 -----------"
    if [[ "$DRY_RUN" == "1" ]]; then
        echo "计划执行             : $planned (生成索引/Release 与签名)"
        echo "真正跳过             : $skipped"
    else
        echo "已生成索引或 Release : $generated"
        echo "已签名               : $signed"
        echo "跳过                 : $skipped"
    fi
    echo "-------------------------------------"
fi

# =========================================================================
# 5. 分发公钥：逐目录比对并更新
# =========================================================================
echo ""
echo "分发公钥到版本目录 ..."
updated=0
missing=0
ok=0

for d in "${VERSION_DIRS[@]}"; do
    target="$d/agiros.gpg"
    rel=$(realpath --relative-to="$REPO_ROOT" "$d")

    # dry-run 且密钥尚未真实生成时，无法比对 MD5，只报告计划
    if [[ -z "$AUTH_MD5" ]]; then
        if [[ -f "$target" ]]; then
            echo -e "${Y}[将覆盖]${C} $rel/agiros.gpg（新密钥，dry-run 未生成无法比对）"
        else
            echo -e "${Y}[将创建]${C} $rel/agiros.gpg（新密钥）"
            missing=$((missing+1))
        fi
        updated=$((updated+1))
        continue
    fi

    if [[ ! -f "$target" ]]; then
        echo -e "${Y}[缺失]${C} $rel/agiros.gpg"
        missing=$((missing+1))
        [[ "$DRY_RUN" == "1" ]] || cp -f "$AUTH_PUB" "$target"
        [[ "$DRY_RUN" == "1" ]] || chmod 644 "$target"
        [[ "$DRY_RUN" == "1" ]] && echo -e "       ${G}[DRY-RUN] 将创建 $target${C}" || echo -e "       ${G}[已写入]${C}"
        updated=$((updated+1))
        continue
    fi

    cur_md5=$(md5sum "$target" | awk '{print $1}')
    if [[ "$cur_md5" != "$AUTH_MD5" ]]; then
        echo -e "${R}[不一致]${C} $rel/agiros.gpg (当前 MD5: $cur_md5)"
        [[ "$DRY_RUN" == "1" ]] || cp -f "$AUTH_PUB" "$target"
        [[ "$DRY_RUN" == "1" ]] && echo -e "         ${G}[DRY-RUN] 将覆盖为权威公钥${C}" || echo -e "         ${G}[已覆盖]${C}"
        updated=$((updated+1))
    else
        echo -e "${G}[一致]${C} $rel/agiros.gpg"
        ok=$((ok+1))
    fi
done

# =========================================================================
# 4. 报告
# =========================================================================
echo ""
echo "============= 分发报告 ============="
echo "版本目录总数: ${#VERSION_DIRS[@]}"
echo "公钥一致   : $ok"
echo "本次更新   : $updated (缺失 $missing / 覆盖 $((updated-missing)))"
if [[ "$DRY_RUN" == "1" ]]; then
    echo -e "${Y}(dry-run 模式，未实际写文件)${C}"
fi
echo "===================================="

# 新密钥提示：公钥换了，签名也必须跟着换
if [[ "$GENERATE_NEW" == "1" && -n "$LOCAL_FPR" && "$DO_SIGN" != "1" ]]; then
    echo ""
    echo -e "${Y}⚠ 重要提醒：本次使用的是新生成的密钥。${C}"
    echo "   只替换 agiros.gpg 是不够的——现有 dists/*/Release.gpg 和 InRelease 仍由旧密钥签名，"
    echo "   客户端 apt update 会因验签失败而报错。必须用新密钥重新签名，例如："
    echo ""
    echo "   cd $REPO_ROOT/ubuntu2204lts/2506"
    echo "   gpg --batch --yes --armor --detach-sign -u $LOCAL_FPR -o dists/jammy/Release.gpg dists/jammy/Release"
    echo "   gpg --batch --yes --clearsign -u $LOCAL_FPR -o dists/jammy/InRelease dists/jammy/Release"
    echo ""
    echo "   每个 ubuntuXXXXlts/YYYY/dists/<codename>/ 都要做一遍。"
fi

# 如果之前临时导出的权威公钥文件在 /tmp 下，清理
if [[ "$AUTH_PUB" == /tmp/* ]]; then
    rm -f "$AUTH_PUB"
fi

