#!/usr/bin/env python3
"""Safely extract V-Zero image TAR shards and verify content hashes."""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import shutil
import tarfile
from pathlib import Path, PurePosixPath


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--root", type=Path, required=True, help="Downloaded dataset repository root")
    return parser.parse_args()


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


def safe_target(root: Path, member: tarfile.TarInfo) -> Path:
    archive_path = PurePosixPath(member.name)
    if archive_path.is_absolute() or ".." in archive_path.parts:
        raise ValueError(f"Unsafe archive member: {member.name}")
    if not archive_path.parts or archive_path.parts[0] != "images":
        raise ValueError(f"Archive member is outside images/: {member.name}")
    target = (root / Path(*archive_path.parts)).resolve()
    try:
        target.relative_to(root)
    except ValueError as error:
        raise ValueError(f"Archive member escapes dataset root: {member.name}") from error
    return target


def main() -> None:
    args = parse_args()
    root = args.root.resolve()
    manifest_path = root / "release_manifest.json"
    shard_root = root / "image_shards"
    if not root.is_dir() or not manifest_path.is_file() or not shard_root.is_dir():
        raise FileNotFoundError("Dataset root must contain release_manifest.json and image_shards/")

    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    expected_count = int(manifest["unique_published_images"])
    extracted = 0
    reused = 0

    shard_paths = sorted(shard_root.glob("*.tar"))
    if len(shard_paths) != int(manifest["shard_count"]):
        raise ValueError(f"Expected {manifest['shard_count']} shards, found {len(shard_paths)}")

    for shard_path in shard_paths:
        with tarfile.open(shard_path, mode="r:") as archive:
            for member in archive:
                target = safe_target(root, member)
                if member.isdir():
                    target.mkdir(parents=True, exist_ok=True)
                    continue
                if not member.isfile():
                    raise ValueError(f"Unsupported archive member type: {member.name}")

                expected_digest = Path(member.name).stem
                if len(expected_digest) != 64:
                    raise ValueError(f"Image filename is not a SHA-256 digest: {member.name}")
                if target.is_file():
                    if target.stat().st_size != member.size or sha256_file(target) != expected_digest:
                        raise ValueError(f"Existing image has unexpected content: {target}")
                    reused += 1
                    continue

                target.parent.mkdir(parents=True, exist_ok=True)
                temporary = target.with_name(f".{target.name}.tmp")
                source = archive.extractfile(member)
                if source is None:
                    raise RuntimeError(f"Unable to read archive member: {member.name}")
                with source, temporary.open("wb") as destination:
                    shutil.copyfileobj(source, destination, length=8 * 1024 * 1024)
                if temporary.stat().st_size != member.size or sha256_file(temporary) != expected_digest:
                    temporary.unlink(missing_ok=True)
                    raise ValueError(f"Extracted image failed verification: {member.name}")
                os.replace(temporary, target)
                extracted += 1

    actual_count = sum(1 for path in (root / "images").glob("*/*") if path.is_file())
    if actual_count != expected_count:
        raise ValueError(f"Expected {expected_count} extracted images, found {actual_count}")
    print(f"Verified {actual_count:,} images ({extracted:,} extracted, {reused:,} already present)")


if __name__ == "__main__":
    main()