#!/usr/bin/env python3
"""Check that a local copy of VLM-UQBench is complete and self-consistent.

Checks that every image and mask path in the manifests and outputs is relative,
stays inside the dataset folder and exists; that the files under images/,
perturbed/ and masks/ match metadata/file_map.jsonl one to one; that the
recorded SHA-256 values agree; and that every output row points to a manifest
row. With --hash it also re-hashes every stored file (reads about 6 GB).

Usage:
    python scripts/verify_release.py [--root .] [--hash]
"""
from __future__ import annotations

import argparse
import hashlib
import json
import sys
from pathlib import Path, PurePosixPath

import pyarrow.parquet as pq

FILE_DIRS = ("images", "perturbed", "masks")


def read_jsonl(path: Path) -> list[dict]:
    with open(path, encoding="utf-8") as f:
        return [json.loads(line) for line in f if line.strip()]


def sha256(path: Path) -> str:
    h = hashlib.sha256()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(1 << 20), b""):
            h.update(chunk)
    return h.hexdigest()


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
    ap.add_argument("--hash", action="store_true", help="re-hash every stored file")
    args = ap.parse_args()
    root = args.root.resolve()
    errors: list[str] = []

    def check_path(p: str, where: str) -> None:
        pp = PurePosixPath(p)
        if pp.is_absolute() or ".." in pp.parts or "\\" in p:
            errors.append(f"{where}: bad path {p!r}")
            return
        full = (root / pp).resolve()
        if root not in full.parents or not full.is_file():
            errors.append(f"{where}: missing or outside root {p!r}")

    # file map <-> files on disk
    fmap = read_jsonl(root / "metadata" / "file_map.jsonl")
    sha_of = {}
    for r in fmap:
        if r["path"] is not None:
            if sha_of.setdefault(r["path"], r["sha256"]) != r["sha256"]:
                errors.append(f"file_map: {r['path']} has two hashes")
    stored = {r["path"] for r in fmap if r["stored"]}
    on_disk = {str(p.relative_to(root)) for d in FILE_DIRS for p in (root / d).rglob("*")
               if p.is_file() and p.name not in ("LICENSE.md",)}
    for p in sorted(on_disk - stored)[:20]:
        errors.append(f"unlisted file {p}")
    for p in sorted(stored - on_disk)[:20]:
        errors.append(f"listed file missing {p}")
    if args.hash:
        for p in sorted(stored):
            if (root / p).is_file() and sha256(root / p) != sha_of[p]:
                errors.append(f"hash mismatch {p}")

    # manifests
    n_paths, uids = 0, set()
    manifests = sorted((root / "manifests").rglob("*.jsonl"))
    for mf in manifests:
        rel = mf.relative_to(root)
        seen = set()
        for i, r in enumerate(read_jsonl(mf)):
            where = f"{rel}:{i + 1}"
            if r["uid"] in seen:
                errors.append(f"{where}: duplicate uid {r['uid']}")
            seen.add(r["uid"])
            for p in ([r["image"]] if r.get("image") else []) + r.get("masks", []):
                n_paths += 1
                check_path(p, where)
            if r.get("image") and r.get("image_sha256") and sha_of.get(r["image"]) != r["image_sha256"]:
                errors.append(f"{where}: image_sha256 differs from file_map")
        uids |= seen

    # outputs
    n_out = 0
    for pf in sorted((root / "outputs").rglob("*.parquet")):
        rel = pf.relative_to(root)
        t = pq.read_table(pf, columns=["uid", "image"]).to_pydict()
        for i, (uid, img) in enumerate(zip(t["uid"], t["image"])):
            n_out += 1
            if uid not in uids:
                errors.append(f"{rel}:{i}: uid not in manifests {uid}")
            if img:
                n_paths += 1
                check_path(img, f"{rel}:{i}")

    print(f"manifests: {len(manifests)} files, {len(uids)} rows; output rows: {n_out}; "
          f"paths checked: {n_paths}; stored files: {len(stored)}"
          + ("; hashes verified" if args.hash else ""))
    for e in errors[:50]:
        print("ERROR", e)
    print("OK" if not errors else f"FAILED ({len(errors)} problems)")
    return 1 if errors else 0


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