"""Run the frozen T4 v1 time-step refinement cohort."""

from __future__ import annotations

import argparse
import json
import os
from pathlib import Path
import tempfile

import h5py
import numpy as np

try:
    from .t4_structural_dynamics import run_trajectory
    from .t4_structural_dynamics_v1 import (
        CASE_DIR,
        DATA_DIR,
        case_config,
        configuration_design,
        load_config,
    )
except ImportError:  # Direct script execution.
    from t4_structural_dynamics import run_trajectory
    from t4_structural_dynamics_v1 import (
        CASE_DIR,
        DATA_DIR,
        case_config,
        configuration_design,
        load_config,
    )


AUDIT_DIR = DATA_DIR / "time_refinement"


def run_audit(configuration_id: int) -> dict:
    global_config = load_config()
    rows = configuration_design(global_config)
    row = rows[configuration_id]
    if configuration_id not in global_config["quality"]["time_refinement_configuration_ids"]:
        raise ValueError(f"Configuration {configuration_id} is not in the frozen audit cohort.")
    output = AUDIT_DIR / f"{row['case_id']}.json"
    if output.is_file():
        cached = json.loads(output.read_text(encoding="utf-8"))
        if (
            cached.get("generator_fix") == "component-preserving-kinematic-bcs"
            and
            float(cached.get("coarse_dt_s", -1.0)) == float(global_config["dynamics"]["dt_s"])
            and float(cached.get("fine_dt_s", -1.0))
            == float(global_config["quality"]["time_refinement_dt_s"])
        ):
            return cached
    with h5py.File(CASE_DIR / f"{row['case_id']}.h5", "r") as h5:
        frequencies = np.asarray(h5["modal/frequencies_hz"])
        coarse_time = np.asarray(h5["trajectories/half_sine_pulse/time_s"])
        coarse_sensors = np.asarray(
            h5["trajectories/half_sine_pulse/sensor_displacement_m"]
        )
    config = case_config(global_config, row)
    with tempfile.TemporaryDirectory(prefix=f"refine_{row['case_id']}_", dir=DATA_DIR) as scratch:
        fine = run_trajectory(
            config,
            config["excitations"][0],
            frequencies_hz=frequencies,
            output_dir=Path(scratch),
            dt=float(global_config["quality"]["time_refinement_dt_s"]),
            save_fields=False,
        )
    fine_on_coarse = np.column_stack(
        [
            np.interp(coarse_time, fine["time_s"], fine["sensor_displacement_m"][:, index])
            for index in range(coarse_sensors.shape[1])
        ]
    )
    relative_l2 = float(
        np.linalg.norm(coarse_sensors - fine_on_coarse)
        / max(np.linalg.norm(fine_on_coarse), np.finfo(float).eps)
    )
    record = {
        "configuration_id": configuration_id,
        "case_id": row["case_id"],
        "generator_fix": "component-preserving-kinematic-bcs",
        "coarse_dt_s": float(config["dynamics"]["dt_s"]),
        "fine_dt_s": float(global_config["quality"]["time_refinement_dt_s"]),
        "five_sensor_history_relative_l2": relative_l2,
        "threshold": float(global_config["quality"]["maximum_time_refinement_relative_l2"]),
        "passed": relative_l2
        <= float(global_config["quality"]["maximum_time_refinement_relative_l2"]),
    }
    AUDIT_DIR.mkdir(parents=True, exist_ok=True)
    temporary = output.with_suffix(".json.tmp")
    temporary.write_text(json.dumps(record, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    os.replace(temporary, output)
    return record


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("configuration_ids", nargs="*", type=int)
    args = parser.parse_args()
    selected = args.configuration_ids or load_config()["quality"]["time_refinement_configuration_ids"]
    for configuration_id in selected:
        print(json.dumps(run_audit(configuration_id), sort_keys=True), flush=True)


if __name__ == "__main__":
    main()