from __future__ import annotations

import json
import math
from pathlib import Path
import tempfile
import unittest

import ap1_m1_balanced_coupled_precision_preflight as precision


ROOT = Path(__file__).resolve().parents[2]
CODE = ROOT / "AP1/CODE/ap1_m1_balanced_coupled_precision_preflight.py"
TEST = Path(__file__).resolve()


class BalancedCoupledPrecisionPreflightTests(unittest.TestCase):
    def test_g32_authority_chain_is_exact_and_pass(self) -> None:
        report, chart = precision.verify_g32_authorities(ROOT)
        self.assertTrue(report["all_preflight_gates_pass"])
        self.assertTrue(chart["all_reference_gates_pass"])

    def test_resolution_floors_are_inherited_without_change(self) -> None:
        self.assertEqual(
            precision.component_resolution_floor("background.H"), 1.0e-10
        )
        self.assertEqual(
            precision.component_resolution_floor("source.rho"), 1.0e-9
        )

    def test_unknown_component_family_fails_closed(self) -> None:
        with self.assertRaises(precision.BalancedCoupledPrecisionPreflightError):
            precision.component_resolution_floor("unknown.value")

    def test_resolved_order_above_half_passes(self) -> None:
        audit = precision.assess_richardson_pair(
            "background.H", 4.0e-7, 1.0e-7, 0.5
        )
        self.assertTrue(audit["monotone"])
        self.assertFalse(audit["both_deltas_below_resolution_floor"])
        self.assertTrue(audit["minimum_order_pass"])
        self.assertAlmostEqual(audit["observed_Richardson_order"], 2.0)

    def test_resolved_order_below_half_fails(self) -> None:
        fine = 1.0e-6 * 2.0 ** -0.49
        audit = precision.assess_richardson_pair(
            "source.rho", 1.0e-6, fine, 0.5
        )
        self.assertTrue(audit["monotone"])
        self.assertFalse(audit["both_deltas_below_resolution_floor"])
        self.assertFalse(audit["minimum_order_pass"])

    def test_below_floor_monotone_pair_passes_without_claimed_order(self) -> None:
        audit = precision.assess_richardson_pair(
            "source.rho", 9.4e-17, 7.9e-17, 0.5
        )
        self.assertTrue(audit["both_deltas_below_resolution_floor"])
        self.assertTrue(audit["monotone"])
        self.assertTrue(audit["minimum_order_pass"])
        self.assertEqual(
            audit["order_gate_basis"],
            "finite_monotone_below_inherited_resolution_floor",
        )

    def test_below_floor_nonmonotone_pair_fails(self) -> None:
        audit = precision.assess_richardson_pair(
            "source.rho", 7.9e-17, 9.4e-17, 0.5
        )
        self.assertTrue(audit["both_deltas_below_resolution_floor"])
        self.assertFalse(audit["monotone"])
        self.assertFalse(audit["minimum_order_pass"])

    def test_nonfinite_pair_fails_closed_and_is_strict_json(self) -> None:
        audit = precision.assess_richardson_pair(
            "background.H", math.nan, 0.0, 0.5
        )
        self.assertFalse(audit["finite_nonnegative"])
        self.assertFalse(audit["minimum_order_pass"])
        json.dumps(audit, allow_nan=False)

    def test_exact_zero_pair_passes_below_floor(self) -> None:
        audit = precision.assess_richardson_pair(
            "background.H", 0.0, 0.0, 0.5
        )
        self.assertTrue(audit["minimum_order_pass"])
        self.assertIsNone(audit["observed_Richardson_order"])

    def test_transport_method_not_switch_count_identifies_implementation(self) -> None:
        exact = {"transport_method": precision.TRANSPORT_METHOD, "dynamic_chart_switches": 0}
        wrong = {"transport_method": "single_R_chart", "dynamic_chart_switches": 5}
        self.assertTrue(precision.exact_transport_used([exact, exact]))
        self.assertFalse(precision.exact_transport_used([exact, wrong]))

    def test_preflight_passes_without_background_or_kernel_run(self) -> None:
        report = precision.build_preflight(ROOT, CODE, TEST)
        self.assertTrue(report["all_preflight_gates_pass"])
        self.assertTrue(all(report["gates"].values()))
        self.assertEqual(report["background_runs"], 0)
        self.assertEqual(report["physical_response_kernel_runs"], 0)
        self.assertFalse(report["production_background_tolerances_frozen"])

    def test_nonpass_is_never_written(self) -> None:
        with tempfile.TemporaryDirectory() as directory:
            output = Path(directory) / "forbidden.json"
            checkpoint = Path(directory) / "forbidden.md"
            with self.assertRaises(
                precision.BalancedCoupledPrecisionPreflightError
            ):
                precision.write_pass_preflight(
                    {"all_preflight_gates_pass": False}, output, checkpoint
                )
            self.assertFalse(output.exists())
            self.assertFalse(checkpoint.exists())

    def test_claim_boundary_retains_every_physical_lock(self) -> None:
        report = precision.build_preflight(ROOT, CODE, TEST)
        self.assertEqual(report["AP1_status"], "ORANGE")
        self.assertFalse(report["seed_released"])
        self.assertFalse(report["nonpass_stored_or_used_as_seed"])
        self.assertFalse(report["equations_changed"])
        self.assertFalse(report["physics_changed"])
        self.assertFalse(report["parameters_changed"])
        self.assertFalse(report["existing_gate_thresholds_changed"])


if __name__ == "__main__":
    unittest.main()