from __future__ import annotations

import json
from pathlib import Path
from typing import Any

import numpy as np

HC_EV_NM = 1239.841984
METERS_PER_NM = 1e-9


def wavelength_nm_from_energy_ev(energy_ev: float) -> float:
    """
    Convert photon energy to wavelength in nanometers.

    Parameters
    ----------
    energy_ev : float
        Photon energy in eV.

    Returns
    -------
    float
        Wavelength in nm.
    """
    return HC_EV_NM / float(energy_ev)


def lambda_to_nm(
    coord_lambda: float | np.ndarray,
    energy_ev: float,
) -> float | np.ndarray:
    """
    Convert lambda-normalized coordinates to nanometers.

    Parameters
    ----------
    coord_lambda : float or numpy.ndarray
        Coordinate value(s) in units of wavelength.
    energy_ev : float
        Photon energy in eV.

    Returns
    -------
    float or numpy.ndarray
        Coordinate value(s) in nanometers.
    """
    return np.asarray(coord_lambda, dtype=float) * wavelength_nm_from_energy_ev(energy_ev)


def geometry_at_energy(path: str | Path, energy_ev: float) -> dict[str, Any]:
    """
    Load geometry JSON and scale shape points to nanometers.

    Parameters
    ----------
    path : str or Path
        Path to ``geometry.json``.
    energy_ev : float
        Photon energy in eV.

    Returns
    -------
    dict
        Geometry manifest with points in nanometers.
    """
    geometry = json.loads(Path(path).read_text(encoding="utf-8"))
    units = geometry.get("units", "lambda")
    if units == "nm":
        return geometry
    if units != "lambda":
        raise ValueError(f"Unsupported geometry units: {units!r}")
    wavelength_nm = wavelength_nm_from_energy_ev(energy_ev)
    for shape in geometry.get("shapes", []):
        points = np.asarray(shape["points"], dtype=float)
        shape["points"] = (points * wavelength_nm).tolist()
    geometry["units"] = "nm"
    geometry["energy_ev"] = energy_ev
    geometry["wavelength_nm"] = wavelength_nm
    return geometry


def _grid_units_from_npz(data: np.lib.npyio.NpzFile) -> str:
    if "units" in data:
        return str(np.asarray(data["units"]).item())
    return "m"


def _coords_in_nm(
    *,
    x_grid: np.ndarray,
    y_grid: np.ndarray,
    units: str,
    energy_ev: float,
) -> tuple[np.ndarray, np.ndarray]:
    if units == "m":
        return x_grid / METERS_PER_NM, y_grid / METERS_PER_NM
    if units == "lambda":
        return lambda_to_nm(x_grid, energy_ev), lambda_to_nm(y_grid, energy_ev)
    if units == "nm":
        return x_grid, y_grid
    raise ValueError(f"Unsupported grid units: {units!r}")


def load_json_artifact(path: str | Path) -> dict[str, Any]:
    """
    Load a JSON artifact shipped with the exported dataset.

    Parameters
    ----------
    path : str or Path
        Path to a JSON file such as ``geometry.json`` or a manifest.

    Returns
    -------
    dict
        Parsed JSON payload.
    """
    return json.loads(Path(path).read_text(encoding="utf-8"))


def load_domain_ids(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]:
    """
    Load domain-id raster data with grid coordinates in nanometers.

    Parameters
    ----------
    path : str or Path
        Path to ``domain_ids.npz``.
    energy_ev : float
        Photon energy in eV for lambda-unit grids.

    Returns
    -------
    dict
        ``domain_ids``, ``X_nm``, ``Y_nm``, and metadata keys.
    """
    with np.load(Path(path)) as data:
        units = _grid_units_from_npz(data)
        domain_ids = np.asarray(data["domain_ids"])
        x_grid = np.asarray(data["X"], dtype=float)
        y_grid = np.asarray(data["Y"], dtype=float)
    x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev)
    return {
        "domain_ids": domain_ids,
        "X": x_grid,
        "Y": y_grid,
        "X_nm": x_nm,
        "Y_nm": y_nm,
        "grid_units": units,
        "energy_ev": energy_ev,
    }


def load_nk_tensor(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]:
    """
    Load nk tensor raster data with grid coordinates in nanometers.

    Parameters
    ----------
    path : str or Path
        Path to ``nk_tensor.npz``.
    energy_ev : float
        Photon energy in eV for lambda-unit grids.

    Returns
    -------
    dict
        ``nk_tensor``, ``domain_ids``, ``X_nm``, ``Y_nm``, and metadata keys.
    """
    with np.load(Path(path)) as data:
        units = _grid_units_from_npz(data)
        nk_tensor = np.asarray(data["nk_tensor"])
        domain_ids = np.asarray(data["domain_ids"])
        x_grid = np.asarray(data["X"], dtype=float)
        y_grid = np.asarray(data["Y"], dtype=float)
        payload = {key: np.asarray(data[key]) for key in data.files}
    x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev)
    payload["X_nm"] = x_nm
    payload["Y_nm"] = y_nm
    payload["grid_units"] = units
    payload["energy_ev"] = energy_ev
    return payload


def load_electric_field(path: str | Path, energy_ev: float) -> dict[str, np.ndarray | float | str]:
    """
    Load an electric-field raster with coordinates in nanometers.

    Parameters
    ----------
    path : str or Path
        Path to ``electric_field.npz``.
    energy_ev : float
        Photon energy in eV for lambda-unit grids.

    Returns
    -------
    dict
        ``electric_field``, coordinate grids, and stored metadata keys.
    """
    with np.load(Path(path)) as data:
        units = _grid_units_from_npz(data)
        x_grid = np.asarray(data["X"], dtype=float)
        y_grid = np.asarray(data["Y"], dtype=float)
        payload = {key: np.asarray(data[key]) for key in data.files}
    x_nm, y_nm = _coords_in_nm(x_grid=x_grid, y_grid=y_grid, units=units, energy_ev=energy_ev)
    payload["X_nm"] = x_nm
    payload["Y_nm"] = y_nm
    payload["grid_units"] = units
    payload["energy_ev"] = energy_ev
    return payload


def load_sample(sample_dir: str | Path, energy_ev: float) -> dict[str, Any]:
    """
    Load core assets for one squiggles sample at a chosen energy scale.

    Parameters
    ----------
    sample_dir : str or Path
        Path to ``sample_XXXX`` directory.
    energy_ev : float
        Photon energy in eV.

    Returns
    -------
    dict
        Geometry, domain map, and available labeled-region tensors.
    """
    root = Path(sample_dir)
    result: dict[str, Any] = {
        "sample_id": root.name,
        "energy_ev": energy_ev,
        "wavelength_nm": wavelength_nm_from_energy_ev(energy_ev),
    }
    geometry_path = root / "geometry.json"
    if geometry_path.is_file():
        result["geometry"] = geometry_at_energy(geometry_path, energy_ev)
        result["geometry_manifest"] = load_json_artifact(geometry_path)
    domain_path = root / "domain_ids.npz"
    if domain_path.is_file():
        result["domain_ids"] = load_domain_ids(domain_path, energy_ev)
    ooc_root = root / "ooc"
    if ooc_root.is_dir():
        ooc: dict[str, dict[str, Any]] = {}
        sweep_manifest_path = ooc_root / "oc_sweep_manifest.json"
        if sweep_manifest_path.is_file():
            result["ooc_sweep_manifest"] = load_json_artifact(sweep_manifest_path)
        for case_dir in sorted(path for path in ooc_root.iterdir() if path.is_dir()):
            case_payload: dict[str, Any] = {}
            manifest_path = case_dir / "oc_manifest.json"
            if manifest_path.is_file():
                case_payload["manifest"] = load_json_artifact(manifest_path)
            nk_path = case_dir / "nk_tensor.npz"
            if nk_path.is_file():
                case_payload["nk_tensor"] = load_nk_tensor(nk_path, energy_ev)
            if case_payload:
                ooc[case_dir.name] = case_payload
        if ooc:
            result["ooc"] = ooc
    fields_root = root / "fields"
    if fields_root.is_dir():
        fields: dict[str, dict[str, Any]] = {}
        for run_dir in sorted(path for path in fields_root.iterdir() if path.is_dir()):
            run_payload: dict[str, Any] = {}
            manifest_path = run_dir / "field_manifest.json"
            if manifest_path.is_file():
                run_payload["manifest"] = load_json_artifact(manifest_path)
            electric_field_path = run_dir / "electric_field.npz"
            if electric_field_path.is_file():
                run_payload["electric_field"] = load_electric_field(electric_field_path, energy_ev)
            nk_path = run_dir / "nk_tensor.npz"
            if nk_path.is_file():
                run_payload["nk_tensor"] = load_nk_tensor(nk_path, energy_ev)
            if run_payload:
                fields[run_dir.name] = run_payload
        if fields:
            result["fields"] = fields
    return result