"""Oak oracles read committed state through the independent reader, not the worktree or binary."""

from pathlib import Path

import sys

import tempfile

import unittest

import unittest.mock

from types import SimpleNamespace

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

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

try:

    from tests.test_oak_sqlite_reader import SyntheticRepo

except ImportError:  # discover -s tests

    from test_oak_sqlite_reader import SyntheticRepo

import parallel_contention  # noqa: E402

import task_loop  # noqa: E402

from oakbench import integrity  # noqa: E402

from oakbench import purezstd  # noqa: E402

class WiringTests(unittest.TestCase):

    def setUp(self):

        self.tmp = tempfile.TemporaryDirectory()

        self.addCleanup(self.tmp.cleanup)

        self.repo = SyntheticRepo(Path(self.tmp.name) / "repo")

        self.repo.commit(self.repo.file_tree({"payload.txt": b"committed payload\n"}))

        # The worktree disagrees with the commit: a worktree oracle would pass.

        (self.repo.root / "payload.txt").write_bytes(b"worktree only\n")

    def corrupt(self):

        with self.repo.db() as db:

            db.execute("UPDATE blobs SET content=? WHERE size=?",

                       (purezstd.encode_raw(b"committed paylo4d\n"), len(b"committed payload\n")))

    def test_integrity_reads_committed_head_as_strong_source(self):

        fields = integrity.content_integrity_fields(

            self.repo.root, operation="snapshot", process_returncode=0,

            expected_payloads={"payload.txt": "committed payload"})

        self.assertTrue(fields["content_integrity_check_passed"], fields)

        self.assertEqual(fields["content_integrity_source"], integrity.OAK_READER_PAYLOAD_SOURCE)

        self.assertTrue(fields["content_integrity_public_trust_passed"])

        worktree_only = integrity.content_integrity_fields(

            self.repo.root, operation="snapshot", process_returncode=0,

            expected_payloads={"payload.txt": "worktree only"})

        self.assertFalse(worktree_only["content_integrity_check_passed"])

    def test_integrity_flags_corrupt_committed_state(self):

        self.corrupt()

        fields = integrity.content_integrity_fields(

            self.repo.root, operation="snapshot", process_returncode=0,

            expected_payloads={"payload.txt": "committed payload"})

        self.assertFalse(fields["content_integrity_check_passed"])

        self.assertIn("oak_committed_state_invalid", fields["content_integrity_failure_reason"])

    def test_contention_payload_and_deep_integrity_use_the_reader(self):

        subject = SimpleNamespace(kind="oak", bin="oak")

        self.assertEqual(parallel_contention.tree_payload(subject, self.repo.root, "payload.txt"), "committed payload\n")

        self.assertEqual(parallel_contention.oak_committed_integrity(self.repo.root)[0], True)

        self.corrupt()

        self.assertIsNone(parallel_contention.tree_payload(subject, self.repo.root, "payload.txt"))

        verified, how = parallel_contention.oak_committed_integrity(self.repo.root)

        self.assertIs(verified, False)

        self.assertIn("invalid", how)

    def test_task_loop_committed_state_helper(self):

        text, head = task_loop.independent_committed_state(self.repo.root, "payload.txt")

        self.assertEqual(text, "committed payload\n")

        self.assertRegex(head, "^[0-9a-f]{64}$")

        self.assertEqual(task_loop.independent_committed_text(self.repo.root, "absent.txt"), "")

        self.corrupt()

        self.assertEqual(task_loop.independent_committed_state(self.repo.root, "payload.txt"), ("", None))

    # QA P2-1: an unavailable reader (format drift, bounds) is unmeasured in

    # every oracle; the correct-looking worktree must never turn it into a pass.

    def make_unavailable(self):

        (self.repo.root / "payload.txt").write_bytes(b"committed payload\n")  # worktree now "correct"

        with self.repo.db() as db:

            db.execute("INSERT INTO schema_migrations VALUES ('9999_future_format','x',1)")

    def test_integrity_unavailable_is_unmeasured_not_worktree_pass(self):

        self.make_unavailable()

        fields = integrity.content_integrity_fields(

            self.repo.root, operation="snapshot", process_returncode=0,

            expected_payloads={"payload.txt": "committed payload"})

        self.assertIsNone(fields["content_integrity_check_passed"], fields)

        self.assertFalse(fields["content_integrity_public_trust_passed"])

        self.assertIn("oak_reader_unavailable", fields["content_integrity_unmeasured_reason"])

    def test_contention_unavailable_is_unmeasured(self):

        self.make_unavailable()

        subject = SimpleNamespace(kind="oak", bin="oak")

        with self.assertRaises(parallel_contention.CommittedStateUnmeasured):

            parallel_contention.tree_payload(subject, self.repo.root, "payload.txt")

        self.assertIsNone(parallel_contention.oak_committed_integrity(self.repo.root)[0])

        self.assertEqual(parallel_contention.unmeasured_returncode(None, 0), 77)

        self.assertEqual(parallel_contention.unmeasured_returncode(True, 0), 0)

    def test_contention_integrity_check_reports_unmeasured(self):

        self.make_unavailable()

        subject = SimpleNamespace(kind="oak", bin="/usr/bin/true", name="oak")

        result = SimpleNamespace(succeeded_payloads=[("payload.txt", "committed payload")])

        with unittest.mock.patch.object(parallel_contention, "snapshot_commands", return_value=[]):

            passed, lost, method = parallel_contention.integrity_check(subject, self.repo.root, [result])

        self.assertIsNone(passed)

        self.assertIsNone(lost)

        self.assertIn("unmeasured", method)

    def test_task_loop_unavailable_is_none_not_worktree(self):

        self.make_unavailable()

        self.assertEqual(task_loop.independent_committed_state(self.repo.root, "payload.txt"), (None, None))

if __name__ == "__main__":

    unittest.main()