"""HHT reference identity, time, projection and common-tolerance regressions."""

import csv
import json
import math
from pathlib import Path
import shutil
import subprocess
import sys

import pytest

h5py = pytest.importorskip("h5py", reason="Run with uv --with h5py for HHT comparison tests.")
np = pytest.importorskip("numpy")
from scripts.verification import compare_hht_dynamic as comparator


@pytest.fixture(scope="module")
def artifacts(tmp_path_factory):
    directory = tmp_path_factory.mktemp("hht-comparison")
    input_path = comparator.REFERENCE_DIRECTORY / f"{comparator.CASE}.inp"
    reference_path = comparator.REFERENCE_DIRECTORY / f"{comparator.CASE} displacements.csv"
    nodes, content_identity = comparator.input_inventory(input_path)
    reference = comparator.read_reference(reference_path)
    result_path = directory / "matching_results.h5"
    string_type = h5py.string_dtype("utf-8")
    node_type = np.dtype([("internal_node_id", "<u8"), ("instance_name", string_type),
                          ("source_label", string_type), ("coordinates", "<f8", (3,))])
    node_rows = np.empty(729, dtype=node_type)
    labels = list(nodes)
    for index, label in enumerate(labels):
        node_rows[index] = (index, "PART-1-1", str(label), nodes[label])
    frame_type = np.dtype([("frame_index", "<u8"), ("increment_index", "<u8"),
                           ("time", "<f8"), ("iteration_count", "<u8"), ("is_initial", "u1")])
    frames = np.empty(101, dtype=frame_type)
    with h5py.File(result_path, "w") as file:
        metadata = file.create_group("metadata")
        metadata.attrs.update({
            "feature_id": "hht-implicit-dynamics", "analysis_procedure": "hht-implicit-dynamics",
            "mass_formulation": "nodal-lumped-kinetic", "internal_formulation": "FESA-MITC4-total-lagrangian",
            "initial_state": "zero-q-v-step-load-0+",
            "acceleration_convention": "physical-endpoint-and-auxiliary-separated",
            "source_step_name": "Step-1", "step_name": "Step-1", "unit_system_label": "consistent-input-units",
            "solver_version": "test-fixture", "source_input_identity": f"path={input_path};content_identity={content_identity}",
            "schema_version": np.uint64(1), "increment_count": np.uint64(100), "maximum_increments": np.uint64(1000),
            "alpha": -0.05, "beta": 0.275625, "gamma": 0.55, "initial_increment": 0.1, "time_period": 10.0,
        })
        file.create_dataset("model/nodes", data=node_rows)
        for increment in range(101):
            time = float(increment) * 0.1
            frames[increment] = (increment, increment, time, 0 if increment == 0 else 2, int(increment == 0))
            values = np.zeros((729, 6), dtype="<f8")
            for label in (2, 21, 22, 69, 70, 165, 309, 442, 586):
                values[labels.index(label)] = reference[(increment, label)]
            dataset = file.create_dataset(f"steps/Step-1/frames/{increment}/nodal/displacement", data=values)
            dataset.attrs.update({
                "component_names": "UX,UY,UZ,URX,URY,URZ", "component_unit_dimensions": "length,length,length,1,1,1",
                "coordinate_system": "global-cartesian", "location": "nodal", "step_name": "Step-1", "source_step_name": "Step-1",
                "rotation_representation": "total-rotation-vector-chart",
                "quantity_semantics": "global-translation-and-total-rotation-vector",
                "schema_version": np.uint64(1), "frame_index": np.uint64(increment), "increment_index": np.uint64(increment),
                "time": time, "is_initial": np.uint8(increment == 0),
            })
        file.create_dataset("steps/Step-1/accepted_frames", data=frames)
    return input_path, reference_path, result_path


def changed_result(tmp_path, artifacts):
    target = tmp_path / "changed.h5"
    shutil.copyfile(artifacts[2], target)
    return target


def reduced_result(tmp_path, artifacts):
    path = changed_result(tmp_path, artifacts)
    with h5py.File(path, "r+") as file:
        file["metadata"].attrs.modify("schema_version", np.uint64(2))
        file["metadata"].attrs["time_integration_formulation"] = (
            "reduced-coordinate-HHT-with-physical-rate-reconstruction")
        for frame in range(101):
            root = f"steps/Step-1/frames/{frame}/nodal"
            displacement = file[f"{root}/displacement"]
            displacement.attrs.modify("schema_version", np.uint64(2))
            auxiliary = file.create_dataset(f"{root}/algorithmic_acceleration",
                                            data=np.zeros((729, 6), dtype="<f8"))
            for name, value in displacement.attrs.items():
                auxiliary.attrs[name] = value
            auxiliary.attrs["component_names"] = "AUX1,AUX2,AUX3,AUX4,AUX5,AUX6"
            auxiliary.attrs["coordinate_system"] = "fixed-initial-global-chart"
            auxiliary.attrs["component_unit_dimensions"] = (
                "length/time^2,length/time^2,length/time^2,1/time^2,1/time^2,1/time^2")
            auxiliary.attrs["quantity_semantics"] = (
                "full-chart-HHT-filter-combination-not-predictor-driver")
    return path


def test_reduced_schema_preserves_displacement_comparison(tmp_path, artifacts):
    result = comparator.compare(artifacts[0], artifacts[1], reduced_result(tmp_path, artifacts))
    assert result["precheck"]["passed"], result["precheck"]
    assert result["verdict"] == "passed"


@pytest.mark.parametrize("mutation", ["missing_A", "A_semantics", "A_version", "A_nan", "method"])
def test_reduced_schema_rejects_inconsistent_auxiliary_history(tmp_path, artifacts, mutation):
    path = reduced_result(tmp_path, artifacts)
    with h5py.File(path, "r+") as file:
        auxiliary = file["steps/Step-1/frames/99/nodal/algorithmic_acceleration"]
        if mutation == "missing_A":
            del file[auxiliary.name]
        elif mutation == "A_semantics":
            auxiliary.attrs["quantity_semantics"] = "auxiliary-HHT-chart-acceleration"
        elif mutation == "A_version":
            auxiliary.attrs.modify("schema_version", np.uint64(1))
        elif mutation == "A_nan":
            auxiliary[0, 0] = float("nan")
        else:
            file["metadata"].attrs["time_integration_formulation"] = "full-coordinate-HHT"
    result = comparator.compare(artifacts[0], artifacts[1], path)
    assert not result["precheck"]["passed"]
    assert result["families"] == []


def test_original_csv_exact_matching_history_and_deterministic_report(artifacts):
    first = comparator.compare(*artifacts)
    second = comparator.compare(*artifacts)
    assert first == second
    assert first["precheck"]["passed"], first["precheck"]
    assert first["precheck"]["reference_row_count"] == 909
    assert first["precheck"]["checked_result_scalars"] == 441774
    assert first["verdict"] == "passed"
    assert first["warnings"] == []
    assert len(first["families"]) == 202
    assert sum(family["row_count"] for family in first["families"]) == 5454
    assert [family["quantity"] for family in first["families"][:4]] == ["U", "UR", "U", "UR"]
    assert all(family["passed"] for family in first["families"])
    assert first["families"][0]["reference_scale"] == 0.0
    assert first["families"][6]["hdf5_time"] == 3 * 0.1
    assert first["families"][6]["reference_decimal_time"] == "0.3"
    assert 3 * 0.1 != float("0.3")  # Both legitimate representations were validated independently.
    json.dumps(first, allow_nan=False)


@pytest.mark.parametrize("mutation,code", [
    ("procedure", "wrong-hdf5-attribute-value"),
    ("mass", "wrong-hdf5-attribute-value"),
    ("coefficient", "wrong-hdf5-attribute-value"),
    ("initial_convention", "wrong-hdf5-attribute-value"),
    ("input_content", "wrong-input-content-identity"),
    ("component", "wrong-hdf5-attribute-value"),
    ("rotation", "wrong-hdf5-attribute-value"),
    ("missing_component_attribute", "missing-hdf5-attribute"),
    ("nonprojected_nan", "nonfinite-result-value"),
    ("rotation_inf", "nonfinite-result-value"),
    ("initial_motion", "nonzero-initial-displacement"),
    ("duplicate_node", "duplicate-result-node"),
    ("extra_node_label", "extra-result-node"),
    ("wrong_instance", "wrong-result-instance"),
    ("coordinate", "wrong-result-coordinate"),
    ("wrong_shape", "wrong-hdf5-dataset-layout"),
    ("float32", "wrong-displacement-type"),
    ("missing_frame", "result-frame-inventory"),
    ("extra_frame", "result-frame-inventory"),
    ("leading_zero_frame", "result-frame-inventory"),
    ("duplicate_increment", "wrong-result-frame-time"),
    ("decimal_binary_time", "wrong-result-frame-time"),
    ("frame_attribute_time", "wrong-hdf5-attribute-value"),
    ("trial_iteration", "wrong-result-frame-time"),
    ("initial_iteration", "wrong-result-frame-time"),
])
def test_hdf5_precheck_rejects_before_tolerance(tmp_path, artifacts, mutation, code):
    path = changed_result(tmp_path, artifacts)
    with h5py.File(path, "r+") as file:
        metadata = file["metadata"]
        displacement = file["steps/Step-1/frames/3/nodal/displacement"]
        nodes = file["model/nodes"]
        table = file["steps/Step-1/accepted_frames"]
        if mutation in {"procedure", "mass", "coefficient", "initial_convention", "input_content"}:
            key, value = {
                "procedure": ("analysis_procedure", "linear-static"),
                "mass": ("mass_formulation", "consistent-kinetic"),
                "coefficient": ("alpha", 0.0),
                "initial_convention": ("initial_state", "unloaded"),
                "input_content": ("source_input_identity", "wrong-content"),
            }[mutation]
            metadata.attrs.modify(key, value)
        elif mutation in {"component", "rotation", "frame_attribute_time"}:
            key, value = {"component": ("component_names", "U1,U2,U3,UR1,UR2,UR3"),
                          "rotation": ("rotation_representation", "incremental-rotation"),
                          "frame_attribute_time": ("time", 0.3)}[mutation]
            displacement.attrs.modify(key, value)
        elif mutation == "missing_component_attribute":
            del displacement.attrs["component_names"]
        elif mutation in {"nonprojected_nan", "rotation_inf"}:
            displacement[0, 0 if mutation == "nonprojected_nan" else 3] = float("nan") if mutation == "nonprojected_nan" else float("inf")
        elif mutation == "initial_motion":
            file["steps/Step-1/frames/0/nodal/displacement"][0, 0] = 1.0e-100
        elif mutation in {"duplicate_node", "extra_node_label", "wrong_instance", "coordinate"}:
            rows = nodes[:]
            if mutation == "duplicate_node":
                rows[1]["source_label"] = rows[0]["source_label"]
            elif mutation == "extra_node_label":
                rows[0]["source_label"] = "99999"
            elif mutation == "wrong_instance":
                rows[0]["instance_name"] = "Other"
            else:
                rows[0]["coordinates"] = [1.0, 2.0, 3.0]
            nodes[:] = rows
        elif mutation in {"wrong_shape", "float32"}:
            name = displacement.name
            values = displacement[:]
            del file[name]
            file.create_dataset(name, data=values[:-1] if mutation == "wrong_shape" else values.astype("<f4"))
        elif mutation == "missing_frame":
            del file["steps/Step-1/frames/100"]
        elif mutation == "extra_frame":
            file.create_group("steps/Step-1/frames/101")
        elif mutation == "leading_zero_frame":
            file.move("steps/Step-1/frames/1", "steps/Step-1/frames/01")
        else:
            rows = table[:]
            if mutation == "duplicate_increment":
                rows[3]["increment_index"] = 2
            elif mutation == "decimal_binary_time":
                rows[3]["time"] = 0.3
            elif mutation == "trial_iteration":
                rows[3]["iteration_count"] = 101
            elif mutation == "initial_iteration":
                rows[0]["iteration_count"] = 1
            table[:] = rows
    report = comparator.compare(artifacts[0], artifacts[1], path)
    assert report["precheck"]["passed"] is False
    assert report["precheck"]["code"] == code, report["precheck"]
    assert report["families"] == []
    assert report["verdict"] == "failed"


@pytest.mark.parametrize("mutation,code", [
    ("duplicate_header", "duplicate-reference-column"),
    ("missing_header", "missing-reference-column"),
    ("duplicate_row", "duplicate-reference-row"),
    ("missing_row", "reference-row-inventory"),
    ("extra_node", "reference-row-inventory"),
    ("extra_frame", "reference-row-inventory"),
    ("time", "wrong-reference-time"),
    ("instance", "wrong-reference-instance"),
    ("label", "invalid-node-label"),
    ("nonfinite_rotation", "nonfinite-reference-value"),
])
def test_reference_precheck_rejects_before_tolerance(tmp_path, artifacts, mutation, code):
    with artifacts[1].open(newline="", encoding="utf-8") as stream:
        rows = list(csv.reader(stream))
    if mutation == "duplicate_header":
        rows[0][-1] = rows[0][-2]
    elif mutation == "missing_header":
        rows[0][-1] = "Not a required component"
    elif mutation == "duplicate_row":
        rows.append(rows[1])
    elif mutation == "missing_row":
        rows.pop()
    elif mutation in {"extra_node", "extra_frame"}:
        row = rows[1].copy()
        if mutation == "extra_node":
            row[2] = "1"
        else:
            row[0] = "Increment 101: Step Time = 10.1"
        rows.append(row)
    elif mutation == "time":
        rows[1][0] = "Increment 0: Step Time = 0.0000000001"
    elif mutation == "instance":
        rows[1][1] = "WRONG-INSTANCE"
    elif mutation == "label":
        rows[1][2] = "2.0"
    else:
        rows[1][-1] = "nan"
    reference = tmp_path / "changed.csv"
    with reference.open("w", newline="", encoding="utf-8") as stream:
        csv.writer(stream).writerows(rows)
    report = comparator.compare(artifacts[0], reference, artifacts[2])
    assert not report["precheck"]["passed"]
    assert report["precheck"]["code"] == code, report["precheck"]
    assert report["families"] == []


def test_projection_joins_source_identity_and_csv_order_is_irrelevant(tmp_path, artifacts):
    path = changed_result(tmp_path, artifacts)
    with h5py.File(path, "r+") as file:
        nodes = file["model/nodes"][:][::-1]
        nodes["internal_node_id"] = np.arange(729, dtype="<u8")
        file["model/nodes"][:] = nodes
        for frame in range(101):
            values = file[f"steps/Step-1/frames/{frame}/nodal/displacement"]
            values[:] = values[:][::-1]
    with artifacts[1].open(newline="", encoding="utf-8") as stream:
        rows = list(csv.reader(stream))
    reference = tmp_path / "reordered.csv"
    with reference.open("w", newline="", encoding="utf-8") as stream:
        csv.writer(stream).writerows([rows[0], *reversed(rows[1:])])
    report = comparator.compare(artifacts[0], reference, path)
    assert report["precheck"]["passed"], report["precheck"]
    assert report["verdict"] == "passed"


@pytest.mark.parametrize("component,passed", [(0, False), (3, True)])
def test_translation_blocks_rotation_warns(tmp_path, artifacts, component, passed):
    path = changed_result(tmp_path, artifacts)
    with h5py.File(path, "r+") as file:
        values = file["steps/Step-1/frames/1/nodal/displacement"]
        rows = values[:]
        rows[:, component:component + 3] *= 2.0
        values[:] = rows
    report = comparator.compare(artifacts[0], artifacts[1], path)
    assert report["precheck"]["passed"]
    assert report["blocking_passed"] is passed
    assert len(report["warnings"]) == (2 if passed else 0)
    if passed:
        assert [warning["code"] for warning in report["warnings"]] == ["row-tolerance-failure", "relative-rms-failure"]
    else:
        assert report["blocking_failures"] == ["U-global:Step-1:increment-1"]


def test_common_policy_boundaries_and_zero_scale():
    near = comparator.evaluate_family(1, "U", [100.0, 2.0, 1.0], [100.0, 1.0, 0.0])
    assert near["passed"]
    assert [row["branch"] for row in near["rows"]] == ["relative", "near-zero", "near-zero"]
    relative = comparator.evaluate_family(1, "U", [105.0], [100.0])
    assert relative["rows_passed"] and not relative["rms_passed"]
    boundary = comparator.evaluate_family(1, "U", [101.0], [100.0])
    assert boundary["passed"]
    assert boundary["relative_rms"] == 0.01
    outside = comparator.evaluate_family(1, "U", [math.nextafter(101.0, math.inf)], [100.0])
    assert outside["rows_passed"] and not outside["rms_passed"]
    zero = comparator.evaluate_family(0, "U", [0.0], [0.0])
    assert zero["passed"] and zero["relative_rms"] is None
    nonzero = comparator.evaluate_family(0, "U", [1.0e-300], [0.0])
    assert not nonzero["passed"]
    assert nonzero["diagnostic_code"] == "zero-reference-scale-nonzero-error"
    json.dumps(nonzero, allow_nan=False)
    with pytest.raises(comparator.ComparisonError, match="U"):
        comparator.evaluate_family(1, "U", [1.0e308], [-1.0e308])


def test_cli_writes_json_and_exit_two_for_missing_results(tmp_path, artifacts):
    report = tmp_path / "evidence.json"
    completed = subprocess.run([sys.executable, "-B", str(Path(comparator.__file__)),
        "--input", str(artifacts[0]), "--reference", str(artifacts[1]),
        "--results", str(tmp_path / "absent.h5"), "--report", str(report)],
        check=False, capture_output=True, text=True)
    assert completed.returncode == 2, completed.stderr
    evidence = json.loads(report.read_text())
    assert not evidence["precheck"]["passed"]
    assert evidence["families"] == []