#!/usr/bin/env python3
"""在没有 apt-ftparchive 的系统（如 openEuler / CentOS）上生成 Debian 仓库索引。

两个子命令，行为对齐 apt-ftparchive：

  packages --root <版本目录> --pool <pool/x86_64> --out <Packages>
      扫描 pool 下的 .deb，输出 Packages 内容（含 Filename/Size/MD5sum/SHA1/SHA256）。

  release  --root <版本目录> --codename <noble> --version <2606> \
           --archs "amd64 arm64" --out <Release>
      对 dists/<codename>/main/binary-*/Packages(.gz) 计算哈希，输出 Release。

只依赖 Python 3 标准库；zstd 压缩的 control.tar 通过系统 tar/zstd 解压。
"""

import argparse
import gzip
import hashlib
import io
import lzma
import os
import subprocess
import sys
import tempfile

AR_MAGIC = b"!<arch>\n"


def iter_ar_members(path):
    """流式遍历 ar 归档（.deb 就是一个 ar 归档），yield (name, data)。"""
    with open(path, "rb") as fh:
        if fh.read(8) != AR_MAGIC:
            raise ValueError(f"不是合法的 deb(ar) 文件: {path}")
        while True:
            header = fh.read(60)
            if len(header) < 60:
                return
            name = header[0:16].decode("utf-8", "replace").strip()
            name = name.rstrip("/")
            try:
                size = int(header[48:58].decode("ascii").strip())
            except ValueError:
                return
            data = fh.read(size)
            if size % 2 == 1:
                fh.read(1)  # ar 数据按偶数字节对齐
            yield name, data


def extract_control(deb_path):
    """返回 .deb 中 control 文件的文本内容。"""
    for name, data in iter_ar_members(deb_path):
        if not name.startswith("control.tar"):
            continue
        suffix = name.split(".tar", 1)[1] if ".tar" in name else ""
        if suffix in ("", ".gz", ".xz", ".bz2"):
            if suffix == ".gz":
                raw = gzip.decompress(data)
            elif suffix == ".xz":
                raw = lzma.decompress(data)
            elif suffix == ".bz2":
                import bz2
                raw = bz2.decompress(data)
            else:
                raw = data
            import tarfile
            with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as tar:
                for member in tar.getmembers():
                    if os.path.basename(member.name) == "control":
                        return tar.extractfile(member).read().decode("utf-8", "replace")
        elif suffix == ".zst":
            with tempfile.NamedTemporaryFile(suffix=".tar.zst", delete=False) as tmp:
                tmp.write(data)
                tmp_path = tmp.name
            try:
                out = subprocess.run(
                    ["tar", "--zstd", "-xOf", tmp_path, "./control"],
                    capture_output=True,
                )
                if out.returncode != 0:
                    out = subprocess.run(
                        ["tar", "--zstd", "-xOf", tmp_path, "control"],
                        capture_output=True,
                    )
                if out.returncode != 0:
                    raise RuntimeError(f"解压 control.tar.zst 失败: {deb_path}")
                return out.stdout.decode("utf-8", "replace")
            finally:
                os.unlink(tmp_path)
    raise RuntimeError(f"未找到 control.tar.*: {deb_path}")


def hashes(path):
    md5 = hashlib.md5()
    sha1 = hashlib.sha1()
    sha256 = hashlib.sha256()
    size = 0
    with open(path, "rb") as fh:
        while True:
            chunk = fh.read(1024 * 1024)
            if not chunk:
                break
            size += len(chunk)
            md5.update(chunk)
            sha1.update(chunk)
            sha256.update(chunk)
    return size, md5.hexdigest(), sha1.hexdigest(), sha256.hexdigest()


def cmd_packages(args):
    root = os.path.abspath(args.root)
    pool_dir = os.path.join(root, args.pool)
    if not os.path.isdir(pool_dir):
        raise SystemExit(f"pool 目录不存在: {pool_dir}")

    entries = []
    for dirpath, _dirnames, filenames in os.walk(pool_dir):
        for fn in filenames:
            if fn.endswith(".deb"):
                entries.append(os.path.join(dirpath, fn))
    entries.sort()

    stanzas = []
    for deb in entries:
        rel = os.path.relpath(deb, root).replace(os.sep, "/")
        size, md5, sha1, sha256 = hashes(deb)
        control = extract_control(deb).strip("\n")

        lines = [ln for ln in control.splitlines()]
        # 去掉可能存在的 Signature/空白行
        body = "\n".join(lines).strip()
        stanza = body + "\n"
        stanza += f"Filename: {rel}\n"
        stanza += f"Size: {size}\n"
        stanza += f"MD5sum: {md5}\n"
        stanza += f"SHA1: {sha1}\n"
        stanza += f"SHA256: {sha256}\n"
        stanzas.append(stanza)

    with open(args.out, "w", encoding="utf-8") as fh:
        if stanzas:
            fh.write("\n".join(stanzas))
        else:
            fh.write("")

    print(f"  扫描到 {len(stanzas)} 个 deb", file=sys.stderr)


def cmd_release(args):
    root = os.path.abspath(args.root)
    dist_dir = os.path.join(root, "dists", args.codename)
    if not os.path.isdir(dist_dir):
        raise SystemExit(f"目录不存在: {dist_dir}")

    files = []
    for arch in args.archs.split():
        base = os.path.join(dist_dir, "main", f"binary-{arch}")
        for name in ("Packages", "Packages.gz"):
            p = os.path.join(base, name)
            if os.path.isfile(p):
                files.append(p)

    if not files:
        raise SystemExit("没有找到任何 Packages 文件")

    md5_rows, sha1_rows, sha256_rows = [], [], []
    for p in sorted(files):
        rel = os.path.relpath(p, dist_dir).replace(os.sep, "/")
        size, md5, sha1, sha256 = hashes(p)
        md5_rows.append(f" {md5} {size} {rel}")
        sha1_rows.append(f" {sha1} {size} {rel}")
        sha256_rows.append(f" {sha256} {size} {rel}")

    date = subprocess.run(
        ["date", "-Ru"], capture_output=True, text=True
    ).stdout.strip()
    if not date:
        import email.utils
        import time
        date = email.utils.formatdate(time.time(), usegmt=True)

    lines = [
        "Origin: AGIROS Repository",
        "Label: AGIROS",
        f"Suite: {args.codename}",
        f"Codename: {args.codename}",
        f"Version: {args.version}",
        f"Date: {date}",
        f"Architectures: {args.archs}",
        "Components: main",
        "Description: AGIROS 软件仓库",
        "MD5Sum:",
    ]
    lines += md5_rows
    lines.append("SHA1:")
    lines += sha1_rows
    lines.append("SHA256:")
    lines += sha256_rows
    lines.append("")

    with open(args.out, "w", encoding="utf-8") as fh:
        fh.write("\n".join(lines))

    print(f"  收录 {len(files)} 个索引文件", file=sys.stderr)


def main():
    parser = argparse.ArgumentParser(description="生成 Debian 仓库索引")
    sub = parser.add_subparsers(dest="cmd", required=True)

    p1 = sub.add_parser("packages")
    p1.add_argument("--root", required=True)
    p1.add_argument("--pool", required=True)
    p1.add_argument("--out", required=True)
    p1.set_defaults(func=cmd_packages)

    p2 = sub.add_parser("release")
    p2.add_argument("--root", required=True)
    p2.add_argument("--codename", required=True)
    p2.add_argument("--version", required=True)
    p2.add_argument("--archs", required=True)
    p2.add_argument("--out", required=True)
    p2.set_defaults(func=cmd_release)

    args = parser.parse_args()
    args.func(args)


if __name__ == "__main__":
    main()

