#!/usr/bin/env python3
import argparse
import json
from pathlib import Path

import numpy as np


def main():
    p = argparse.ArgumentParser(description="Validate ds16k expert dataset integrity")
    p.add_argument("--dataset-root", required=True)
    p.add_argument("--expect-classes", type=int, default=32)
    p.add_argument("--expect-traces-per-class", type=int, default=10000)
    p.add_argument("--expect-len", type=int, default=16384)
    p.add_argument("--expect-dtype", type=str, default="float32")
    p.add_argument("--seed", type=int, default=7)
    p.add_argument("--val-size", type=int, default=10000)
    p.add_argument("--out", type=str, default="verify_summary.json")
    args = p.parse_args()

    root = Path(args.dataset_root).expanduser().resolve()
    classes = sorted([d for d in root.iterdir() if d.is_dir() and d.name.startswith("expert_")])
    if len(classes) != int(args.expect_classes):
        raise SystemExit(f"expected {args.expect_classes} classes, got {len(classes)}")

    all_ids = []
    total = 0
    out = {
        "dataset_root": str(root),
        "class_count": int(len(classes)),
        "per_class": [],
    }

    for c in classes:
        tpath = c / "traces.npy"
        idpath = c / "trial_ids.npy"
        if not tpath.exists() or not idpath.exists():
            raise SystemExit(f"missing files in {c}")

        t = np.load(tpath, mmap_mode="r")
        ids = np.load(idpath)
        if t.ndim != 2:
            raise SystemExit(f"{tpath} must be 2D")
        if t.shape[0] != int(args.expect_traces_per_class):
            raise SystemExit(f"{c.name} traces count mismatch: {t.shape[0]}")
        if t.shape[1] != int(args.expect_len):
            raise SystemExit(f"{c.name} trace length mismatch: {t.shape[1]}")
        if str(t.dtype) != str(args.expect_dtype):
            raise SystemExit(f"{c.name} dtype mismatch: {t.dtype}")
        if ids.shape != (int(args.expect_traces_per_class),):
            raise SystemExit(f"{c.name} trial_ids shape mismatch: {ids.shape}")

        uid = np.unique(ids)
        out["per_class"].append(
            {
                "class": c.name,
                "shape": [int(t.shape[0]), int(t.shape[1])],
                "dtype": str(t.dtype),
                "trial_id_min": int(ids.min()),
                "trial_id_max": int(ids.max()),
                "trial_id_unique": int(len(uid)),
            }
        )

        all_ids.append(ids.astype(np.int64))
        total += int(t.shape[0])

    all_ids = np.concatenate(all_ids, axis=0)
    unique_groups = sorted(set(int(x) for x in all_ids.tolist()))
    if len(unique_groups) < 2:
        raise SystemExit("need >=2 unique trial groups")

    rng = np.random.default_rng(int(args.seed))
    rng.shuffle(unique_groups)
    group_sizes = {g: int(np.sum(all_ids == g)) for g in unique_groups}

    target = int(args.val_size)
    running = 0
    best_i = 1
    best_diff = float("inf")
    for i, g in enumerate(unique_groups, start=1):
        if i >= len(unique_groups):
            break
        running += group_sizes[g]
        diff = abs(running - target)
        if diff < best_diff:
            best_diff = diff
            best_i = i

    val_groups = set(unique_groups[:best_i])
    val_mask = np.isin(all_ids, np.array(list(val_groups), dtype=np.int64))

    out["total_traces"] = int(total)
    out["grouped_split_preview"] = {
        "seed": int(args.seed),
        "val_size_target": int(args.val_size),
        "val_size_actual": int(val_mask.sum()),
        "train_size": int((~val_mask).sum()),
        "val_group_count": int(len(val_groups)),
    }

    out_path = root / args.out
    with open(out_path, "w") as f:
        json.dump(out, f, indent=2)

    print("[ok] dataset verified")
    print("[ok] total_traces", out["total_traces"])
    print("[ok] split train={} val={} groups={}".format(
        out["grouped_split_preview"]["train_size"],
        out["grouped_split_preview"]["val_size_actual"],
        out["grouped_split_preview"]["val_group_count"],
    ))
    print("[ok] wrote", out_path)


if __name__ == "__main__":
    main()