#!/usr/bin/env python3
"""Load automotive-impact cases from extracted files or ZIP shards."""

from __future__ import annotations

import argparse
import io
import json
import zipfile
from pathlib import Path

import numpy as np
import torch


GEOMETRY_ALIASES = {
    "floorfrontdriver": "floorfrontdriver",
    "driver": "floorfrontdriver",
    "floorfrontr": "floorfrontR",
    "floorfrontR": "floorfrontR",
    "trunk": "trunkfloor",
    "trunkfloor": "trunkfloor",
}


def canonical_geometry(name: str) -> str:
    if name in GEOMETRY_ALIASES:
        return GEOMETRY_ALIASES[name]
    lowered = name.lower()
    if lowered in GEOMETRY_ALIASES:
        return GEOMETRY_ALIASES[lowered]
    choices = ", ".join(sorted(set(GEOMETRY_ALIASES.values())))
    raise ValueError(f"unknown geometry {name!r}; choose one of {choices}")


def canonical_case_id(value: str | int) -> str:
    if isinstance(value, int):
        number = value
    else:
        text = str(value).strip()
        if text.lower().endswith(".pt"):
            text = text[:-3]
        if text.lower().startswith("case"):
            text = text[4:]
        number = int(text)
    if not 1 <= number <= 500:
        raise ValueError(f"case number must be in [1,500], got {number}")
    return f"case{number:03d}"


def shard_name(case_id: str) -> str:
    number = int(case_id[4:])
    start = ((number - 1) // 100) * 100 + 1
    end = start + 99
    return f"cases_{start:03d}_{end:03d}.zip"


def load_case_bytes(dataset_root: Path | str, geometry: str, case_id: str | int) -> bytes:
    root = Path(dataset_root)
    geometry = canonical_geometry(geometry)
    case_id = canonical_case_id(case_id)

    candidates = (
        root / "data" / geometry / "cases" / f"{case_id}.pt",
        root / "data" / geometry / f"{case_id}.pt",
    )
    for candidate in candidates:
        if candidate.is_file():
            return candidate.read_bytes()

    archive = root / "data" / geometry / shard_name(case_id)
    if not archive.is_file():
        raise FileNotFoundError(
            f"case not extracted and shard is missing: {archive}"
        )
    member = f"cases/{case_id}.pt"
    with zipfile.ZipFile(archive) as handle:
        try:
            return handle.read(member)
        except KeyError as exc:
            raise FileNotFoundError(f"{member} is missing from {archive}") from exc


def load_case(dataset_root: Path | str, geometry: str, case_id: str | int) -> dict:
    payload = load_case_bytes(dataset_root, geometry, case_id)
    return torch.load(io.BytesIO(payload), map_location="cpu", weights_only=True)


def load_mesh(dataset_root: Path | str, geometry: str) -> dict[str, np.ndarray]:
    root = Path(dataset_root)
    geometry = canonical_geometry(geometry)
    path = root / "meshes" / f"{geometry}_mesh.npz"
    if not path.is_file():
        raise FileNotFoundError(path)
    with np.load(path, allow_pickle=False) as archive:
        return {key: archive[key].copy() for key in archive.files}


def load_split(dataset_root: Path | str) -> dict[str, list[str]]:
    path = Path(dataset_root) / "metadata" / "split_400_50_50_seed12345.json"
    return json.loads(path.read_text(encoding="utf-8"))


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dataset-root", type=Path, default=Path("."))
    parser.add_argument("--geometry", required=True)
    parser.add_argument("--case", required=True)
    args = parser.parse_args()

    geometry = canonical_geometry(args.geometry)
    case_id = canonical_case_id(args.case)
    data = load_case(args.dataset_root, geometry, case_id)
    mesh = load_mesh(args.dataset_root, geometry)

    summary = {
        "geometry": geometry,
        "case": data["case"],
        "disp_shape": list(data["disp"].shape),
        "effective_stress_shape": list(data["effective_stress"].shape),
        "time": data["time"].tolist(),
        "impact_xyz": data["impact_xyz"].tolist(),
        "velocity_xyz": data["velocity_xyz"].tolist(),
        "mass_ratio": float(data["mass_ratio"]),
        "material_young_mpa": float(data["material_young_mpa"]),
        "material_poisson": float(data["material_poisson"]),
        "mesh_node_count": int(mesh["node_pos"].shape[0]),
        "mesh_element_count": int(mesh["element_node_index"].shape[0]),
    }
    print(json.dumps(summary, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()