#!/usr/bin/env python3
"""Validate one versioned StatePlay archive and pin its 100 evaluation cases."""
from __future__ import annotations

import argparse
import csv
import json
from collections import Counter
from pathlib import Path

import cv2
import pandas as pd

from prepare_new_generation_benchmark import dataset_file, sha256_file, verify_packaged_files
from stateplay.constants import SF3_BUTTON_COLS
from stateplay_eval import normalized_label


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dataset", type=Path, required=True)
    parser.add_argument("--archive", type=Path, required=True)
    parser.add_argument("--archive-version", choices=("test_03", "test_04"), required=True)
    parser.add_argument("--expected-release", choices=("test_02", "test_03"), required=True)
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()

    dataset = args.dataset.resolve()
    archive = args.archive.resolve()
    if not dataset.is_dir() or not archive.is_file():
        raise FileNotFoundError("Extracted dataset and source ZIP must both exist")
    verify_packaged_files(dataset)
    build = json.loads((dataset / "build_info.json").read_text(encoding="utf-8"))
    expected = (100, "sfiii_new_generation", "Ibuki (Round 1)", args.expected_release)
    observed = (build.get("clip_count"), build.get("game"), build.get("stage"), build.get("release_name"))
    if observed != expected or build.get("fps") != 20 or build.get("frames_per_clip") != 100:
        raise ValueError(f"Unexpected archive release metadata: {observed}")

    with (dataset / "metadata_state_polish.csv").open(newline="", encoding="utf-8-sig") as handle:
        metadata = list(csv.DictReader(handle))
    with (dataset / "selection_manifest.csv").open(newline="", encoding="utf-8-sig") as handle:
        source_rows = list(csv.DictReader(handle))
    source_by_video = {row["video"]: row for row in source_rows}
    if len(metadata) != 100 or len(source_rows) != 100 or len(source_by_video) != 100:
        raise ValueError("Expected 100 unique metadata and source rows")

    prefix = args.archive_version.replace("test_", "t")
    samples = []
    for index, row in enumerate(metadata, start=1):
        source = source_by_video.get(row["video"])
        if source is None or row["action"] != source["action"]:
            raise ValueError(f"Missing matching source identity: {row['video']}")
        label = normalized_label(row["distribution"])
        if label != normalized_label(source["category"]):
            raise ValueError(f"Mechanics category mismatch: {row['video']}")
        video = dataset_file(dataset, row["video"])
        actions = dataset_file(dataset, row["action"])
        if video.parent.name != source["clip_id"]:
            raise ValueError(f"Clip identity mismatch: {video}")
        frame_actions = pd.read_parquet(actions)
        required = {"timer", "p1_hp", "p2_hp", "p1_meter", "p2_meter", *SF3_BUTTON_COLS}
        if len(frame_actions) != 100 or required - set(frame_actions.columns):
            raise ValueError(f"Invalid action/state table: {actions}")
        cap = cv2.VideoCapture(str(video))
        try:
            frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
            fps = cap.get(cv2.CAP_PROP_FPS)
            first_frame_ok = cap.read()[0]
        finally:
            cap.release()
        if frames != 100 or abs(fps - 20) > 0.1 or not first_frame_ok:
            raise ValueError(f"Invalid reference video: {video} ({frames=} {fps=})")
        prompt = row["prompt"].strip()
        if not prompt:
            raise ValueError(f"Empty prompt for {video}")
        sample_id = f"{prefix}_{index:03d}"
        samples.append({
            "id": sample_id,
            "source_kind": "independent_versioned_selftest",
            "source_id": source["clip_id"],
            "label": label,
            "input_image": None,
            "source_video": str(video),
            "reference_video": str(video),
            "actions": str(actions),
            "prompt": prompt,
            "output_name": f"{sample_id}_{label}_{source['clip_id']}.mp4",
            "identity": {
                "video_sha256": sha256_file(video),
                "actions_file_sha256": sha256_file(actions),
                "source_action_fingerprint": source["action_sha256"],
                "episode_id": source["episode_id"],
            },
        })

    counts = Counter(item["label"] for item in samples)
    if len(counts) != 5 or dict(counts) != {
        normalized_label(label): int(count) for label, count in build["class_counts"].items()
    }:
        raise ValueError(f"Class counts differ from build_info: {dict(counts)}")
    result = {
        "benchmark_name": f"stateplay_{args.archive_version}_archive_100_v1",
        "warning": "Independent self-test, not the paper authors' unpublished test set.",
        "archive_version": args.archive_version,
        "internal_release_name": args.expected_release,
        "source_archive": str(archive),
        "source_archive_sha256": sha256_file(archive),
        "dataset_root": str(dataset),
        "class_counts": dict(sorted(counts.items())),
        "samples": samples,
    }
    output = args.output.resolve()
    output.parent.mkdir(parents=True, exist_ok=True)
    temporary = output.with_suffix(".tmp")
    temporary.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    if output.exists() and output.read_bytes() != temporary.read_bytes():
        temporary.unlink()
        raise ValueError(f"Existing selection differs; refusing to remap outputs: {output}")
    temporary.replace(output)
    print(f"Prepared {len(samples)} verified {args.archive_version} clips from internal {args.expected_release}: {output}")


if __name__ == "__main__":
    main()