#!/usr/bin/env python3
"""Validate the standardized DeepMind Lagrangian Water dataset package."""

from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path


EXPECTED_SPLITS = {
    "train": 1000,
    "valid": 30,
    "test": 30,
}


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


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


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--dataset-root", default=".", help="dataset package root")
    parser.add_argument(
        "--verify-sha256",
        action="store_true",
        help="recompute and verify SHA256 values from files_sha256.jsonl",
    )
    parser.add_argument(
        "--skip-tfrecord-read",
        action="store_true",
        help="skip optional TensorFlow first-record readability check",
    )
    return parser.parse_args()


def load_metadata(data_dir: Path) -> dict:
    meta_path = data_dir / "metadata.json"
    if not meta_path.is_file():
        fail(f"missing metadata file: {meta_path}")
    metadata = json.loads(meta_path.read_text(encoding="utf-8"))
    if metadata.get("dim") != 2:
        fail(f"expected metadata dim=2, got {metadata.get('dim')}")
    if metadata.get("sequence_length") != 1000:
        fail(f"expected sequence_length=1000, got {metadata.get('sequence_length')}")
    for key in ["vel_mean", "vel_std", "acc_mean", "acc_std"]:
        value = metadata.get(key)
        if not isinstance(value, list) or len(value) != 2:
            fail(f"metadata {key} must be a length-2 list")
    return metadata


def check_files(dataset_root: Path) -> dict:
    data_dir = dataset_root / "data" / "Water"
    if not data_dir.is_dir():
        fail(f"missing data directory: {data_dir}")
    sizes = {}
    for split in EXPECTED_SPLITS:
        path = data_dir / f"{split}.tfrecord"
        if not path.is_file():
            fail(f"missing TFRecord split: {path}")
        size = path.stat().st_size
        if size <= 0:
            fail(f"empty TFRecord split: {path}")
        sizes[str(path.relative_to(dataset_root))] = size
    if not (data_dir / "metadata.json").is_file():
        fail("missing data/Water/metadata.json")
    sizes["data/Water/metadata.json"] = (data_dir / "metadata.json").stat().st_size
    return sizes


def verify_inventory(dataset_root: Path, sizes: dict, verify_sha256: bool) -> None:
    inventory_path = dataset_root / "files_sha256.jsonl"
    if not inventory_path.is_file():
        fail("missing files_sha256.jsonl")
    seen = {}
    for line in inventory_path.read_text(encoding="utf-8").splitlines():
        if not line.strip():
            continue
        item = json.loads(line)
        rel_path = item["path"]
        path = dataset_root / rel_path
        if not path.is_file():
            fail(f"inventory path missing on disk: {rel_path}")
        if path.stat().st_size != item["size"]:
            fail(f"size mismatch for {rel_path}")
        if sizes.get(rel_path) != item["size"]:
            fail(f"required file size mismatch for {rel_path}")
        if verify_sha256:
            actual = sha256_file(path)
            if actual != item["sha256"]:
                fail(f"sha256 mismatch for {rel_path}")
        seen[rel_path] = item
    missing = sorted(set(sizes) - set(seen))
    if missing:
        fail(f"inventory missing required files: {missing}")


def check_tfrecord_first_record(data_dir: Path, metadata: dict) -> None:
    try:
        import numpy as np
        import tensorflow.compat.v1 as tf
    except Exception as exc:  # pragma: no cover - depends on runtime env
        print(f"[WARN] TensorFlow first-record check skipped: {exc}")
        return

    feature_description = {"position": tf.io.VarLenFeature(tf.string)}
    context_features = {
        "key": tf.io.FixedLenFeature([], tf.int64, default_value=0),
        "particle_type": tf.io.VarLenFeature(tf.string),
    }
    expected_steps = metadata["sequence_length"] + 1
    dim = metadata["dim"]
    for split in EXPECTED_SPLITS:
        record_iter = iter(tf.data.TFRecordDataset(str(data_dir / f"{split}.tfrecord")).take(1))
        try:
            raw = next(record_iter)
        except StopIteration:
            fail(f"{split}.tfrecord contains no records")
        context, features = tf.io.parse_single_sequence_example(
            raw,
            context_features=context_features,
            sequence_features=feature_description,
        )
        position = np.frombuffer(features["position"].values[0].numpy(), dtype=np.float32)
        if position.size % (expected_steps * dim) != 0:
            fail(f"{split}.tfrecord first record position shape is incompatible with metadata")
        particle_type = np.frombuffer(context["particle_type"].values[0].numpy(), dtype=np.int64)
        num_particles = position.size // (expected_steps * dim)
        if particle_type.shape[0] != num_particles:
            fail(f"{split}.tfrecord particle_type length does not match position particles")
        print(
            f"[OK] {split}.tfrecord first record: "
            f"position_shape=({expected_steps}, {num_particles}, {dim}), "
            "position_dtype=float32, particle_type_dtype=int64"
        )


def main() -> None:
    args = parse_args()
    dataset_root = Path(args.dataset_root).resolve()
    data_dir = dataset_root / "data" / "Water"
    sizes = check_files(dataset_root)
    metadata = load_metadata(data_dir)
    verify_inventory(dataset_root, sizes, args.verify_sha256)
    if not args.skip_tfrecord_read:
        check_tfrecord_first_record(data_dir, metadata)
    print("[OK] Lagrangian Water dataset validation passed")


if __name__ == "__main__":
    main()