#!/usr/bin/env python3
"""Export the Hugging Face VCR dataset back to the original r2c layout."""

from __future__ import annotations

import argparse
import json
import os
import shutil
from itertools import islice
from pathlib import Path

from datasets import load_dataset, load_from_disk
from huggingface_hub import hf_hub_download
from tqdm import tqdm


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("repo_id", help="Hugging Face dataset repo id, e.g. rowanz/vcr")
    parser.add_argument("output_dir", type=Path, help="Directory to create in r2c-compatible layout")
    parser.add_argument("--token", default=None, help="HF token for private/gated repos")
    parser.add_argument("--limit", type=int, default=None, help="Optional per-split row limit for smoke tests")
    parser.add_argument("--local-stage-dir", type=Path, default=None, help="Use a local vcr_hf.py stage directory instead of the Hub")
    args = parser.parse_args()

    args.output_dir.mkdir(parents=True, exist_ok=True)
    images_dir = args.output_dir / "vcr1images"
    images_dir.mkdir(parents=True, exist_ok=True)

    for split in ("train", "val", "test"):
        if args.local_stage_dir is None:
            src = hf_hub_download(
                repo_id=args.repo_id,
                repo_type="dataset",
                filename=f"original_annotations/{split}.jsonl",
                token=args.token,
            )
        else:
            src = args.local_stage_dir / "original_annotations" / f"{split}.jsonl"
        dst = args.output_dir / f"{split}.jsonl"
        if args.limit is None:
            shutil.copyfile(src, dst)
        else:
            with open(src, "r", encoding="utf-8") as f_in, open(dst, "w", encoding="utf-8") as f_out:
                for i, line in enumerate(f_in):
                    if i >= args.limit:
                        break
                    f_out.write(line)

    if args.local_stage_dir is None:
        if args.limit is None:
            split_expr = {s: s for s in ("train", "validation", "test")}
            ds = load_dataset(args.repo_id, "image_examples", split=split_expr, token=args.token)
            if not isinstance(ds, dict):
                ds = {"train": ds}
        else:
            ds = {
                split_name: load_dataset(
                    args.repo_id,
                    "image_examples",
                    split=split_name,
                    streaming=True,
                    token=args.token,
                )
                for split_name in ("train", "validation", "test")
            }
    else:
        local_ds = load_from_disk(args.local_stage_dir / "image_examples.dataset")
        ds = {}
        for split_name in ("train", "validation", "test"):
            ds[split_name] = local_ds[split_name].select(range(min(args.limit, len(local_ds[split_name])))) if args.limit else local_ds[split_name]

    seen: set[str] = set()
    for split_name, split_ds in ds.items():
        rows = islice(split_ds, args.limit) if args.limit is not None else split_ds
        for row in tqdm(rows, desc=f"export {split_name} images", total=args.limit):
            img_fn = row["img_fn"]
            metadata_fn = row["metadata_fn"]

            if img_fn not in seen:
                image = row["image"]
                dst_img = images_dir / img_fn
                dst_img.parent.mkdir(parents=True, exist_ok=True)
                image.save(dst_img)
                seen.add(img_fn)

            if metadata_fn not in seen:
                metadata = {
                    "boxes": row["boxes"],
                    "segms": json.loads(row["segms_json"]),
                    "names": row["objects"],
                    "width": row["width"],
                    "height": row["height"],
                }
                dst_meta = images_dir / metadata_fn
                dst_meta.parent.mkdir(parents=True, exist_ok=True)
                with open(dst_meta, "w", encoding="utf-8") as f:
                    json.dump(metadata, f, separators=(",", ":"))
                seen.add(metadata_fn)

    print(f"Wrote r2c-compatible VCR layout to {args.output_dir}", flush=True)
    os._exit(0)


if __name__ == "__main__":
    main()