"""Conformance gate semantics and its wiring into devloop and publish_gate."""

import contextlib

import io

import json

from pathlib import Path

import sys

import tempfile

import unittest

ROOT = Path(__file__).resolve().parents[1]

sys.path.insert(0, str(ROOT / "scripts"))

import devloop  # noqa: E402

import publish_gate  # noqa: E402

from oakbench import conformance_gate as gate  # noqa: E402

from oakbench.conformance import SCENARIOS  # noqa: E402

from oakbench.conformance_matrix import BEHAVIOURS  # noqa: E402

ALL = list(SCENARIOS) + [b.id for b in BEHAVIOURS]

def conformance_row(behaviour, code=0, legs=None, subject="oak", **extra):

    row = {"evidence_class": "diagnostic_conformance", "subject": subject, "scenario": behaviour,

           "returncode": code, "binary_sha256": "b" * 64, **extra}

    if legs is not None:

        row["failed_legs"] = legs

    if code == 1:

        row["failure"] = f"{(legs or ['behaviour'])[0]}: injected"

    if code == 77:

        row.setdefault("skip_reason", "filesystem capability unavailable: case_sensitive_fs")

    return row

def healthy_rows(expected, subject="oak"):

    """Rows matching today's expected failures exactly: the gate's PASS state."""

    rows = []

    for behaviour in ALL:

        entry = expected["entries"].get(behaviour)

        if entry:

            legs = None if behaviour in SCENARIOS else entry["failed_legs"]

            rows.append(conformance_row(behaviour, 1, legs, subject))

        else:

            rows.append(conformance_row(behaviour, 0, None, subject))

    return rows

class EvaluateTests(unittest.TestCase):

    def setUp(self):

        self.expected = gate.load_expected()

    def test_matching_expected_failures_pass(self):

        result = gate.evaluate(healthy_rows(self.expected), self.expected, ALL)

        self.assertEqual(result["verdict"], "PASS", result)

        self.assertEqual(len(result["expected_failures"]), len(self.expected["entries"]))

    def test_new_failure_is_a_regression(self):

        rows = healthy_rows(self.expected)

        rows = [r for r in rows if r["scenario"] != "eol_crlf_v1"] + [conformance_row("eol_crlf_v1", 1, ["clone_fs"])]

        result = gate.evaluate(rows, self.expected, ALL)

        self.assertEqual(result["verdict"], "REGRESSED")

        self.assertIn("eol_crlf_v1", result["regressions"][0])

    def test_known_failure_changing_shape_is_a_regression(self):

        rows = [r for r in healthy_rows(self.expected) if r["scenario"] != "path_tab_v1"]

        rows.append(conformance_row("path_tab_v1", 1, ["clone_fs", "clone_read"]))

        result = gate.evaluate(rows, self.expected, ALL)

        self.assertEqual(result["verdict"], "REGRESSED")

        self.assertIn("fb-531", result["regressions"][0])

    def test_fix_flips_to_fixed_without_regression(self):

        rows = [r for r in healthy_rows(self.expected) if r["scenario"] != "path_tab_v1"]

        rows.append(conformance_row("path_tab_v1", 0))

        result = gate.evaluate(rows, self.expected, ALL)

        self.assertEqual(result["verdict"], "PASS")

        self.assertIn("fb-531", result["fixed"][0])

    def test_missing_rows_and_harness_errors_are_unmeasured(self):

        rows = [r for r in healthy_rows(self.expected) if r["scenario"] != "eol_lf_v1"]

        self.assertEqual(gate.evaluate(rows, self.expected, ALL)["verdict"], "UNMEASURED")

        rows.append(conformance_row("eol_lf_v1", 2, failure="harness error"))

        self.assertEqual(gate.evaluate(rows, self.expected, ALL)["verdict"], "UNMEASURED")

        self.assertEqual(gate.evaluate([], self.expected)["verdict"], "UNMEASURED")

    def test_capability_skips_are_recorded_not_unmeasured_but_reader_skips_are(self):

        rows = [r for r in healthy_rows(self.expected) if r["scenario"] != "path_case_distinct_v1"]

        rows.append(conformance_row("path_case_distinct_v1", 77))

        result = gate.evaluate(rows, self.expected, ALL)

        self.assertEqual(result["verdict"], "PASS")

        self.assertEqual(len(result["skipped"]), 1)

        rows[-1] = conformance_row("path_case_distinct_v1", 77, skip_reason="leg unmeasured: reader bound")

        self.assertEqual(gate.evaluate(rows, self.expected, ALL)["verdict"], "UNMEASURED")

    def test_git_rows_never_gate(self):

        rows = healthy_rows(self.expected) + [conformance_row("eol_lf_v1", 1, ["clone_fs"], subject="git")]

        result = gate.evaluate(rows, self.expected, ALL)

        self.assertEqual(result["verdict"], "PASS")

        self.assertEqual(len(result["git_reference_failures"]), 1)

    def test_list_validation_requires_ticket_and_legs(self):

        with tempfile.TemporaryDirectory() as tmp:

            path = Path(tmp) / "x.json"

            for entry in ({"behaviour": "a", "failed_legs": ["clone_fs"]},

                          {"behaviour": "a", "ticket": "TODO", "failed_legs": ["clone_fs"]},

                          {"behaviour": "a", "ticket": "fb-1"}):

                path.write_text(json.dumps({"schema_version": 1, "entries": [entry]}))

                with self.assertRaises(ValueError):

                    gate.load_expected(path)

class WiringTests(unittest.TestCase):

    def setUp(self):

        self.expected = gate.load_expected()

    def test_devloop_lane_is_default_and_maps_verdicts(self):

        self.assertIn("conformance", devloop.LANES)

        regressions, notes = devloop.conformance_checks(healthy_rows(self.expected))

        self.assertEqual(regressions, [])

        self.assertFalse(any(n.startswith("UNMEASURED") for n in notes))

        rows = [r for r in healthy_rows(self.expected) if r["scenario"] != "eol_lf_v1"]

        regressions, notes = devloop.conformance_checks(rows + [conformance_row("eol_lf_v1", 1, ["pull_fs"])])

        self.assertTrue(regressions and regressions[0].startswith("[conformance] CONFORMANCE eol_lf_v1"))

        regressions, notes = devloop.conformance_checks(rows)

        self.assertTrue(any(n.startswith("UNMEASURED conformance") for n in notes))

    def gate_code(self, rows):

        with tempfile.TemporaryDirectory() as tmp:

            path = Path(tmp) / "rows.jsonl"

            path.write_text("".join(json.dumps(r) + "\n" for r in rows))

            with contextlib.redirect_stdout(io.StringIO()) as out:

                code = publish_gate.main([str(path)])

            return code, out.getvalue()

    def test_publish_gate_requires_and_checks_conformance_for_oak_rows(self):

        oak_row = {"subject": "oak_installed", "binary_sha256": "b" * 64, "returncode": 0,

                   "source": {"oak_hash": "abc", "oak_status": "clean"}}

        code, out = self.gate_code([oak_row])

        self.assertIn("FAIL   conformance: Oak rows published without", out)

        code, out = self.gate_code([oak_row, *healthy_rows(self.expected)])

        self.assertIn("PASS   conformance (oak): PASS", out)

        stale = [r for r in healthy_rows(self.expected) if r["scenario"] != "path_tab_v1"]

        code, out = self.gate_code([oak_row, *stale, conformance_row("path_tab_v1", 0)])

        self.assertIn("expected-failures list is stale", out)

        other = dict(oak_row, binary_sha256="c" * 64)

        code, out = self.gate_code([other, *healthy_rows(self.expected)])

        self.assertIn("published Oak binaries lack conformance rows", out)

if __name__ == "__main__":

    unittest.main()