#!/usr/bin/env python3
"""Validate the standardized CFDBench dataset package."""

from __future__ import annotations

import argparse
import hashlib
import json
import sys
from collections import defaultdict
from pathlib import Path

import numpy as np


REPO_ROOT = Path(__file__).resolve().parents[1]
DATA_ROOT = REPO_ROOT / "data"
CHECKSUM_PATH = REPO_ROOT / "files_sha256.jsonl"
PROBLEMS = ("cavity", "tube", "dam", "cylinder")
SUBSETS = ("bc", "geo", "prop")
REQUIRED_CASE_FILES = ("case.json", "u.npy", "v.npy")
OPTIONAL_EXTENSIONS = {".png"}


def fail(message: str) -> None:
    print(f"[FAIL] {message}")
    raise SystemExit(1)


def ok(message: str) -> None:
    print(f"[OK] {message}")


def warn(message: str) -> None:
    print(f"[WARN] {message}")


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


def iter_case_dirs() -> list[Path]:
    case_dirs = []
    for problem in PROBLEMS:
        problem_dir = DATA_ROOT / problem
        if not problem_dir.is_dir():
            fail(f"missing problem directory: {problem_dir}")
        for subset in SUBSETS:
            subset_dir = problem_dir / subset
            if subset_dir.is_dir():
                cases = sorted(subset_dir.glob("case*"), key=lambda p: int(p.name[4:]))
                if not cases:
                    fail(f"empty subset directory: {subset_dir}")
                case_dirs.extend(cases)
    return case_dirs


def validate_structure(sample_cases_per_subset: int) -> None:
    if not DATA_ROOT.is_dir():
        fail(f"dataset data root does not exist: {DATA_ROOT}")
    counts = defaultdict(int)
    sampled = 0
    for problem in PROBLEMS:
        for subset in SUBSETS:
            subset_dir = DATA_ROOT / problem / subset
            if not subset_dir.is_dir():
                continue
            cases = sorted(subset_dir.glob("case*"), key=lambda p: int(p.name[4:]))
            counts[f"{problem}/{subset}"] = len(cases)
            for case_dir in cases[:sample_cases_per_subset]:
                for name in REQUIRED_CASE_FILES:
                    if not (case_dir / name).is_file():
                        fail(f"missing required case file: {case_dir / name}")
                params = json.loads((case_dir / "case.json").read_text(encoding="utf-8"))
                if not isinstance(params, dict) or not params:
                    fail(f"case.json must be a non-empty object: {case_dir / 'case.json'}")
                u = np.load(case_dir / "u.npy", mmap_mode="r")
                v = np.load(case_dir / "v.npy", mmap_mode="r")
                if u.shape != v.shape:
                    fail(f"u/v shape mismatch: {case_dir}: {u.shape} vs {v.shape}")
                if u.ndim != 3:
                    fail(f"u/v arrays must be 3D time/grid arrays: {case_dir}: {u.shape}")
                if not np.issubdtype(u.dtype, np.number) or not np.issubdtype(v.dtype, np.number):
                    fail(f"u/v dtype must be numeric: {case_dir}: {u.dtype}, {v.dtype}")
                if not np.isfinite(np.asarray(u[0])).all() or not np.isfinite(np.asarray(v[0])).all():
                    fail(f"first frame contains non-finite values: {case_dir}")
                sampled += 1
    if not counts:
        fail("no CFDBench subsets found")
    ok(f"dataset structure and sampled arrays are valid: {sum(counts.values())} cases, sampled {sampled}")


def verify_checksums(full_hash: bool) -> None:
    if not CHECKSUM_PATH.exists():
        warn(f"checksum manifest is not present: {CHECKSUM_PATH}")
        return
    records = []
    for line in CHECKSUM_PATH.read_text(encoding="utf-8").splitlines():
        if line.strip():
            records.append(json.loads(line))
    if not records:
        fail("checksum manifest is empty")
    for record in records:
        path = REPO_ROOT / record["path"]
        if not path.is_file():
            fail(f"checksum entry points to missing file: {path}")
        size = path.stat().st_size
        if size != record["size"]:
            fail(f"size mismatch for {path}: expected {record['size']}, got {size}")
        if full_hash:
            digest = sha256_file(path)
            if digest != record["sha256"]:
                fail(f"sha256 mismatch for {path}")
    mode = "size+sha256" if full_hash else "size"
    ok(f"checksum manifest verified in {mode} mode: {len(records)} files")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--sample-cases-per-subset", type=int, default=2)
    parser.add_argument("--full-hash", action="store_true")
    args = parser.parse_args()
    if args.sample_cases_per_subset < 1:
        fail("--sample-cases-per-subset must be positive")
    validate_structure(args.sample_cases_per_subset)
    verify_checksums(args.full_hash)
    ok("dataset validation completed")
    return 0


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