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

from __future__ import annotations

import argparse
import hashlib
import json
import pickle
import sys
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"
EXPECTED_FILES = ("dataX.pkl", "dataY.pkl")
EXPECTED_SHAPE = (981, 3, 172, 79)
EXPECTED_DTYPE = np.float32


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


def ok(message: str) -> None:
    print(f"[OK] {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 validate_structure() -> None:
    if not DATA_ROOT.is_dir():
        fail(f"dataset data root does not exist: {DATA_ROOT}")
    actual = sorted(path.name for path in DATA_ROOT.iterdir() if path.is_file())
    if actual != sorted(EXPECTED_FILES):
        fail(f"unexpected data file set: expected {sorted(EXPECTED_FILES)}, got {actual}")
    ok("dataset file names and directory layout are valid")


def load_pickle(path: Path) -> np.ndarray:
    with path.open("rb") as handle:
        arr = np.asarray(pickle.load(handle))
    return arr


def validate_arrays(sample_values: bool) -> None:
    arrays = {}
    for name in EXPECTED_FILES:
        path = DATA_ROOT / name
        arr = load_pickle(path)
        arrays[name] = arr
        if arr.shape != EXPECTED_SHAPE:
            fail(f"data/{name} shape mismatch: expected {EXPECTED_SHAPE}, got {arr.shape}")
        if arr.dtype != EXPECTED_DTYPE:
            fail(f"data/{name} dtype mismatch: expected {EXPECTED_DTYPE}, got {arr.dtype}")
        if sample_values and not np.isfinite(arr[0]).all():
            fail(f"data/{name} first sample contains non-finite values")
    if arrays["dataX.pkl"].shape != arrays["dataY.pkl"].shape:
        fail("dataX.pkl and dataY.pkl shapes are inconsistent")
    ok("dataset PKL files are readable and match expected shape/dtype")


def verify_checksums(full_hash: bool) -> None:
    if not CHECKSUM_PATH.exists():
        fail(f"checksum manifest is not present: {CHECKSUM_PATH}")
    records = [json.loads(line) for line in CHECKSUM_PATH.read_text(encoding="utf-8").splitlines() if line.strip()]
    if len(records) != len(EXPECTED_FILES):
        fail(f"checksum manifest must contain {len(EXPECTED_FILES)} records, got {len(records)}")
    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("--full-hash", action="store_true")
    parser.add_argument("--skip-value-sample", action="store_true")
    args = parser.parse_args()
    validate_structure()
    validate_arrays(sample_values=not args.skip_value_sample)
    verify_checksums(full_hash=args.full_hash)
    ok("dataset validation completed")
    return 0


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