#!/usr/bin/env python3
"""Build deterministic per-split/per-modality tar.zst archives.

The source tree is never modified.  A completed archive is atomically renamed
from a `.partial` path, so an interrupted run can be resumed safely.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import subprocess
import sys
from pathlib import Path


MODALITIES = ("image_2", "gt_image_2", "depth_u16", "depth_meters", "normal", "calib")
SPLITS = ("training", "validation")


def sha256(path: Path) -> str:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for block in iter(lambda: f.read(8 * 1024 * 1024), b""):
            h.update(block)
    return h.hexdigest()


def build_one(source_split: Path, modality: str, output: Path, level: int, threads: int) -> None:
    output.parent.mkdir(parents=True, exist_ok=True)
    partial = output.with_suffix(output.suffix + ".partial")
    if output.exists() and output.stat().st_size > 0:
        print(f"[skip] {output} ({output.stat().st_size / 2**30:.2f} GiB)", flush=True)
        return
    if partial.exists():
        partial.unlink()
    tar_cmd = [
        "tar", "--sort=name", "--mtime=UTC 1970-01-01", "--owner=0",
        "--group=0", "--numeric-owner", "--format=gnu", "-C",
        str(source_split), "-cf", "-", modality,
    ]
    zstd_cmd = ["zstd", f"-{level}", f"-T{threads}", "-q", "-o", str(partial)]
    print(f"[build] {output}", flush=True)
    tar_proc = subprocess.Popen(tar_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    assert tar_proc.stdout is not None
    zstd_proc = subprocess.Popen(zstd_cmd, stdin=tar_proc.stdout, stderr=subprocess.PIPE)
    tar_proc.stdout.close()
    zerr = zstd_proc.stderr.read().decode("utf-8", "replace") if zstd_proc.stderr else ""
    zrc = zstd_proc.wait()
    terr = tar_proc.stderr.read().decode("utf-8", "replace") if tar_proc.stderr else ""
    trc = tar_proc.wait()
    if zrc != 0 or trc != 0:
        partial.unlink(missing_ok=True)
        raise RuntimeError(f"archive failed for {modality}: tar={trc} zstd={zrc}\n{terr}\n{zerr}")
    os.replace(partial, output)
    print(f"[done] {output.stat().st_size / 2**30:.2f} GiB sha256={sha256(output)}", flush=True)


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--source-root", type=Path, required=True)
    ap.add_argument("--release-root", type=Path, required=True)
    ap.add_argument("--level", type=int, default=6)
    ap.add_argument("--threads", type=int, default=0, help="zstd threads; 0 means all CPUs")
    args = ap.parse_args()
    for split in SPLITS:
        source_split = args.source_root / split
        for modality in MODALITIES:
            build_one(source_split, modality, args.release_root / split / f"{modality}.tar.zst", args.level, args.threads)
    records = []
    for split in SPLITS:
        for modality in MODALITIES:
            p = args.release_root / split / f"{modality}.tar.zst"
            if not p.exists():
                raise FileNotFoundError(p)
            records.append({"split": split, "modality": modality, "path": str(p.relative_to(args.release_root)), "bytes": p.stat().st_size, "sha256": sha256(p)})
    (args.release_root / "archive_manifest.json").write_text(json.dumps({"archives": records}, indent=2) + "\n", encoding="utf-8")
    return 0


if __name__ == "__main__":
    sys.exit(main())