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

from __future__ import annotations

import argparse
import hashlib
import json
import re
import sys
from pathlib import Path


REPO_ROOT = Path(__file__).resolve().parents[1]
DATASET_ROOT = REPO_ROOT / "data" / "Dataset"
CHECKSUM_PATH = REPO_ROOT / "files_sha256.jsonl"
REQUIRED_SUFFIXES = ("internal.vtu", "freestream.vtp", "aerofoil.vtp")
SCHEMA_HINTS = {
    "internal.vtu": ("UnstructuredGrid", "implicit_distance", "U", "p", "nut"),
    "aerofoil.vtp": ("PolyData", "Normals", "U", "p", "nut"),
    "freestream.vtp": ("PolyData", "U", "p", "nut"),
}


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:
    h = hashlib.sha256()
    with path.open("rb") as f:
        for chunk in iter(lambda: f.read(1024 * 1024), b""):
            h.update(chunk)
    return h.hexdigest()


def load_manifest() -> dict:
    manifest_path = DATASET_ROOT / "manifest.json"
    if not manifest_path.exists():
        fail(f"missing manifest.json: {manifest_path}")
    try:
        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        fail(f"manifest.json is not valid JSON: {exc}")
    for key in ("full_train", "full_test"):
        if key not in manifest or not isinstance(manifest[key], list) or not manifest[key]:
            fail(f"manifest key is missing or empty: {key}")
    return manifest


def inspect_vtk_header(path: Path, suffix: str) -> None:
    blob = path.read_bytes()[:262144].decode("utf-8", errors="ignore")
    if "<VTKFile" not in blob:
        fail(f"not a VTK XML file: {path}")
    for token in SCHEMA_HINTS[suffix]:
        if token not in blob:
            fail(f"schema token {token!r} not found in {path}")
    piece = re.search(r"NumberOfPoints=\"(\d+)\"", blob)
    if piece and int(piece.group(1)) <= 0:
        fail(f"NumberOfPoints is not positive in {path}")


def validate_files(manifest: dict, sample_count: int) -> None:
    actual_dirs = sorted(p for p in DATASET_ROOT.iterdir() if p.is_dir())
    referenced = list(dict.fromkeys(manifest["full_train"] + manifest["full_test"]))
    if len(actual_dirs) != len(referenced):
        fail(f"case count mismatch: dirs={len(actual_dirs)}, manifest_unique={len(referenced)}")

    missing = []
    for sim_name in referenced:
        sim_dir = DATASET_ROOT / sim_name
        if not sim_dir.is_dir():
            missing.append(str(sim_dir))
            continue
        for suffix in REQUIRED_SUFFIXES:
            file_path = sim_dir / f"{sim_name}_{suffix}"
            if not file_path.is_file():
                missing.append(str(file_path))
            elif file_path.stat().st_size <= 0:
                fail(f"empty file: {file_path}")
    if missing:
        fail("missing required files, first entries: " + "; ".join(missing[:8]))

    for sim_name in referenced[:sample_count]:
        for suffix in REQUIRED_SUFFIXES:
            inspect_vtk_header(DATASET_ROOT / sim_name / f"{sim_name}_{suffix}", suffix)
    ok(f"dataset file structure and sampled VTK schema are valid: {len(referenced)} cases")


def verify_checksums(full_hash: bool) -> None:
    if not CHECKSUM_PATH.exists():
        warn(f"checksum manifest is not present: {CHECKSUM_PATH}")
        return
    checked = 0
    for line in CHECKSUM_PATH.read_text(encoding="utf-8").splitlines():
        if not line.strip():
            continue
        record = json.loads(line)
        path = REPO_ROOT / record["path"]
        if not path.exists():
            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}")
        checked += 1
    mode = "size+sha256" if full_hash else "size"
    ok(f"checksum manifest verified in {mode} mode: {checked} files")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--sample-count", type=int, default=3)
    parser.add_argument("--full-hash", action="store_true")
    args = parser.parse_args()
    if args.sample_count < 1:
        fail("--sample-count must be positive")
    if not DATASET_ROOT.exists():
        fail(f"dataset root does not exist: {DATASET_ROOT}")
    manifest = load_manifest()
    validate_files(manifest, args.sample_count)
    verify_checksums(args.full_hash)
    ok("dataset validation completed")
    return 0


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