from __future__ import annotations

import argparse
import json
import os
import signal
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock

import numpy as np

from k2_evalop.analytic_companion import analytic_rows, trapezoid, _write_or_verify_npy
from k2_evalop.common import AuditError, append_jsonl_fsync, file_record, load_json, write_new_json
from k2_evalop.evaluator import pooled_metrics, write_report_markdown
from k2_evalop.hardware import run_idle_probe
from k2_evalop.operator import CampaignLock
from k2_evalop.preflight import _require_identical_receipts
from k2_evalop.sufficient_statistics import integrated_sequence_risk, load_sufficient_statistics
from k2_evalop import supervisor


class LedgerAndStatisticsTests(unittest.TestCase):
    def test_ledger_accepts_multiple_fsynced_appends(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            path = Path(td) / "ledger.jsonl"
            append_jsonl_fsync(path, {"event": "one"})
            append_jsonl_fsync(path, {"event": "two"})
            self.assertEqual([json.loads(line)["event"] for line in path.read_text().splitlines()], ["one", "two"])

    def test_shared_sufficient_stat_loader_and_trapezoid(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            path = Path(td) / "stats.npz"
            n, scalars = 7, 11
            primary = np.arange(n * 16, dtype="<f8").reshape(n, 16)
            early = np.arange(n * 6, dtype="<f8").reshape(n, 6)
            np.savez(path, primary_sse=primary,
                     primary_scalar_count=np.full((n, 16), scalars, dtype="<u4"),
                     early_sse=early,
                     early_scalar_count=np.full((n, 6), scalars, dtype="<u4"))
            loaded = load_sufficient_statistics(path, n_sequence=n, n_scalar=scalars)
            got = integrated_sequence_risk(loaded["primary_sse"], loaded["primary_scalar_count"], n_sequence=n, n_scalar=scalars)
            wanted = (0.5 * primary[:, 0] + primary[:, 1:-1].sum(1) + 0.5 * primary[:, -1]) / 15 / scalars
            np.testing.assert_allclose(got, wanted, rtol=1e-15, atol=0.0)
            self.assertAlmostEqual(trapezoid(np.arange(16, dtype=np.float64)), 7.5)

    def test_nonpositive_full_risk_is_nonadvance_domain_not_exception(self) -> None:
        risks = np.zeros((3, 10_240, 4), dtype=np.float64)
        metrics = pooled_metrics(risks)
        self.assertIsNone(metrics["P_ind"])
        self.assertIsNone(metrics["C_gap"])
        self.assertIn("independent_full_risk_nonpositive", metrics["automatic_non_advance_reasons"])

    def test_analytic_companion_population_identity(self) -> None:
        for rho in (0.1, 0.3):
            row = analytic_rows(rho)
            self.assertGreater(row["g_independent"], 0.0)
            self.assertEqual(row["g_triangular"], 0.0)
            self.assertAlmostEqual(row["C_gap"], 1.0, places=14)

    def test_leaf_symlinks_are_rejected_before_resolution(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            root = Path(td)
            regular = root / "regular.bin"
            regular.write_bytes(b"bytes")
            link = root / "link.bin"
            link.symlink_to(regular)
            with self.assertRaisesRegex(AuditError, "leaf symlink"):
                file_record(link)
            stats = root / "stats.npz"
            np.savez(stats,
                     primary_sse=np.zeros((2, 16), dtype="<f8"),
                     primary_scalar_count=np.full((2, 16), 3, dtype="<u4"),
                     early_sse=np.zeros((2, 6), dtype="<f8"),
                     early_scalar_count=np.full((2, 6), 3, dtype="<u4"))
            stats_link = root / "stats-link.npz"
            stats_link.symlink_to(stats)
            with self.assertRaisesRegex(AuditError, "leaf symlink"):
                load_sufficient_statistics(stats_link, n_sequence=2, n_scalar=3)

    def test_public_cpu_receipt_requires_exact_bytes(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            root = Path(td)
            frozen = root / "frozen.json"
            generated = root / "generated.json"
            frozen.write_bytes(b"same\n")
            generated.write_bytes(b"same\n")
            self.assertEqual(_require_identical_receipts(frozen, generated, "fixture")["sha256"], file_record(frozen)["sha256"])
            generated.write_bytes(b"different\n")
            with self.assertRaisesRegex(AuditError, "public frozen"):
                _require_identical_receipts(frozen, generated, "fixture")

    def test_nonfinite_derived_penalty_is_json_safe_nonadvance(self) -> None:
        risks = np.ones((3, 10_240, 4), dtype=np.float64)
        risks[:, :, 0] = np.nextafter(0.0, 1.0)
        metrics = pooled_metrics(risks)
        self.assertIsNone(metrics["P_ind"])
        self.assertIn("nonfinite_independent_penalty", metrics["automatic_non_advance_reasons"])

    def test_deterministic_cpu_outputs_recover_without_overwrite(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            root = Path(td)
            array = np.arange(12, dtype="<f8").reshape(3, 4)
            first = _write_or_verify_npy(root / "array.npy", array)
            self.assertEqual(_write_or_verify_npy(root / "array.npy", array), first)
            with self.assertRaisesRegex(AuditError, "differs on recovery"):
                _write_or_verify_npy(root / "array.npy", array + 1.0)
            report = root / "k2_report_0000.json"
            write_new_json(report, {
                "status": "NON_ADVANCE", "pooled": {"P_ind": None, "C_gap": None},
                "bootstrap": {"c_gap_lcb95_percentile_2_5": "-Infinity"},
            })
            markdown = write_report_markdown(report)
            before = file_record(markdown)
            self.assertEqual(file_record(write_report_markdown(report)), before)


class IdleAndLockTests(unittest.TestCase):
    def test_two_sample_idle_probe_records_raw_outputs(self) -> None:
        outputs = iter([
            "GPU-test, NVIDIA H200, 0, 686\n", "",
            "GPU-test, NVIDIA H200, 0, 700\n", "",
        ])
        with tempfile.TemporaryDirectory() as td, mock.patch("k2_evalop.hardware._run", side_effect=lambda _argv: next(outputs)):
            path = Path(td) / "idle.json"
            run_idle_probe(path, sleep_fn=lambda seconds: self.assertEqual(seconds, 5.0))
            value = load_json(path)
            self.assertEqual(value["status"], "PASS")
            self.assertEqual(len(value["samples"]), 2)
            self.assertIn("raw_gpu_query_stdout", value["samples"][0])

    def test_idle_probe_rejects_hidden_busy_gpu_without_mutation(self) -> None:
        outputs = iter([
            "GPU-test, NVIDIA H200, 100, 14965\n", "",
            "GPU-test, NVIDIA H200, 100, 14965\n", "",
        ])
        with tempfile.TemporaryDirectory() as td, mock.patch("k2_evalop.hardware._run", side_effect=lambda _argv: next(outputs)):
            path = Path(td) / "idle.json"
            with self.assertRaises(AuditError):
                run_idle_probe(path, sleep_fn=lambda _seconds: None)
            self.assertEqual(load_json(path)["status"], "FAIL")

    def test_campaign_flock_has_one_winner(self) -> None:
        with tempfile.TemporaryDirectory() as td:
            state = Path(td)
            with CampaignLock(state, "first"):
                code = (
                    "from pathlib import Path; from k2_evalop.operator import CampaignLock; "
                    "\ntry:\n CampaignLock(Path(sys.argv[1]),'second').__enter__(); print('BAD')"
                    "\nexcept Exception: print('REJECTED')"
                )
                completed = subprocess.run([sys.executable, "-c", "import sys;" + code, str(state)], text=True, capture_output=True)
                self.assertEqual(completed.stdout.strip(), "REJECTED")


def _fake_idle(path: Path) -> Path:
    write_new_json(path, {"schema_version": 1, "status": "PASS", "receipt": "test"})
    return path


class SupervisorFaultTests(unittest.TestCase):
    def _args(self, root: Path, command: list[str]) -> argparse.Namespace:
        return argparse.Namespace(
            state_root=str(root), phase="test_gpu", lease_id="lease-test",
            controller_pid=os.getpid(), identity_json="{}", command_sha256="0" * 64,
            log_path=str(root / "child.log"), cwd=str(root), budget_seconds=100.0,
            term_margin_seconds=1.0, kill_grace_seconds=0.2, command=command,
        )

    def test_spawn_failure_still_closes_and_charges(self) -> None:
        with tempfile.TemporaryDirectory() as td, mock.patch("k2_evalop.supervisor.run_idle_probe", side_effect=_fake_idle):
            root = Path(td)
            closed = supervisor.supervise(self._args(root, [str(root / "does-not-exist")]))
            value = load_json(closed)
            self.assertEqual(value["status"], "failed")
            self.assertTrue(value["process_group_proven_empty"])
            self.assertFalse(any((root / "leases" / "active").glob("*.json")))
            self.assertEqual(len((root / "ledger.jsonl").read_text().splitlines()), 2)

    def test_log_open_failure_creates_no_active_lease(self) -> None:
        with tempfile.TemporaryDirectory() as td, mock.patch("k2_evalop.supervisor.run_idle_probe", side_effect=_fake_idle):
            root = Path(td)
            (root / "child.log").mkdir()
            with self.assertRaises(OSError):
                supervisor.supervise(self._args(root, [sys.executable, "-c", "pass"]))
            self.assertFalse(any((root / "leases" / "active").glob("*.json")))
            self.assertFalse((root / "ledger.jsonl").exists())

    def test_terminal_ledger_failure_retains_active_evidence(self) -> None:
        with tempfile.TemporaryDirectory() as td, mock.patch("k2_evalop.supervisor.run_idle_probe", side_effect=_fake_idle):
            root = Path(td)
            real = supervisor.append_jsonl_fsync
            calls = 0
            def fail_second(path, value):
                nonlocal calls
                calls += 1
                if calls == 2:
                    raise OSError("injected terminal ledger fault")
                return real(path, value)
            with mock.patch("k2_evalop.supervisor.append_jsonl_fsync", side_effect=fail_second):
                with self.assertRaises(OSError):
                    supervisor.supervise(self._args(root, [sys.executable, "-c", "pass"]))
            self.assertEqual(len(list((root / "leases" / "active").glob("*.json"))), 1)
            self.assertEqual(len(list((root / "leases" / "closed").glob("*.json"))), 1)


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