"""Independent CLI integration: real Git, mock agent, durable campaign records."""

from pathlib import Path

import json

import shutil

import subprocess

import sys

import tempfile

import unittest

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

CLI = ROOT / "scripts" / "agent_campaign.py"

@unittest.skipUnless(shutil.which("git"), "Git is required for the campaign integration")

class CampaignCLIIntegrationTests(unittest.TestCase):

    def setUp(self):

        self.temp = tempfile.TemporaryDirectory(prefix="oakbench-campaign-cli-")

        self.addCleanup(self.temp.cleanup)

        self.root = Path(self.temp.name).resolve()

        self.campaign = self.root / "campaign"

        self.agents = self.root / "agents.toml"

        self.agents.write_text('[agents.mock]\nenabled = true\nadapter = "deterministic_mock"\nprovider = "local"\n')

        self.subjects = self.root / "subjects.toml"

        self.subjects.write_text('[subjects.git]\nenabled = true\nkind = "git"\nlabel = "Git"\nbin = '

                                 + json.dumps(shutil.which("git")) + '\n')

        self.manifest = self.root / "manifest.json"

        self.manifest.write_text(json.dumps({

            "schema_version": 1, "campaign_id": "cli-integration",

            "agents_config": str(self.agents), "subjects_config": str(self.subjects),

            "agents": [{"name": "mock", "model": None}], "subjects": ["git"],

            "workflows": ["wide_config_refactor"], "instruction_levels": ["cheat-sheet"],

            "repetitions": 2, "seed": 194, "max_trials": 2, "max_wall_seconds": 180,

            "trial_timeout_seconds": 30, "track": "agent-default", "agent_environment": "minimal",

        }))

    def invoke(self, command, *args):

        return subprocess.run([sys.executable, str(CLI), command,

                               "--campaign-dir", str(self.campaign), *args],

                              cwd=ROOT, text=True, capture_output=True, timeout=120)

    def plan(self):

        result = self.invoke("plan", "--manifest", str(self.manifest))

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        return json.loads((self.campaign / "plan.json").read_text())

    def fixture_hash(self, plan):

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

        from oakbench import agent_campaign

        import workflow_ab

        agent_campaign.cached_fixture(self.campaign, plan, workflow_ab.WORKFLOWS["wide_config_refactor"])

        record = json.loads((self.campaign / "fixture-integrity/wide_config_refactor.json").read_text())

        return agent_campaign.digest(record["manifest"])

    def events(self):

        return [json.loads(line) for line in (self.campaign / "events.jsonl").read_text().splitlines()]

    def test_real_git_mock_completion_and_noop_resume_preserve_evidence(self):

        plan = self.plan()

        self.assertEqual(len(plan["schedule"]), 2)

        result = self.invoke("run")

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        self.assertEqual(json.loads(result.stdout)["finished"], 2)

        self.assertIn("[trial]", result.stderr)

        events = self.events()

        self.assertEqual([event["event"] for event in events], ["started", "finished"] * 2)

        finished = [event for event in events if event["event"] == "finished"]

        for event in finished:

            self.assertTrue(event["row"]["success"], event)

            self.assertTrue(event["row"]["success_criteria"]["checks"]["required_checks_passed"])

            self.assertEqual(event["row"]["task_id"], event["trial_id"])

        journal = (self.campaign / "events.jsonl").read_bytes()

        # Simulate the crash window after the authoritative terminal fsync but

        # before refreshing the derived rows. Resume must repair this view.

        (self.campaign / "rows.jsonl").write_text("")

        shutil.rmtree(self.campaign / "fixtures")

        shutil.rmtree(self.campaign / "fixture-integrity")

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)

        self.assertFalse((self.campaign / "fixtures").exists())

        recovered = [json.loads(line) for line in (self.campaign / "rows.jsonl").read_text().splitlines()]

        self.assertEqual(recovered, [event["row"] for event in finished])

        result = self.invoke("report")

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        self.assertIn('"claim_eligible": false', result.stdout.lower())

    @unittest.skipUnless(shutil.which("oak"), "Oak is required for the default Git-vs-Oak report")

    def test_default_git_vs_oak_campaign_report_renders_with_refused_pairs(self):

        # Default configuration: no byte-distinct Git instrument and no

        # independent Oak reader, so Git rows carry subject_binary_* evidence

        # and Oak rows subject_produced_*. The report must refuse those pairs,

        # never crash (regression: ValueError -> exit 2, no report).

        self.subjects.write_text(self.subjects.read_text() + '[subjects.oak_installed]\nenabled = true\nkind = "oak"\n'

                                 'label = "Oak"\nbin = ' + json.dumps(shutil.which("oak")) + '\n')

        manifest = json.loads(self.manifest.read_text())

        manifest.update(subjects=["git", "oak_installed"], repetitions=1, max_trials=2)

        self.manifest.write_text(json.dumps(manifest))

        self.plan()

        result = self.invoke("run")

        self.assertIn(result.returncode, (0, 1), result.stdout + result.stderr)

        classes = {event["row"]["subject"]: event["row"].get("workflow_integrity_evidence_class")

                   for event in self.events() if event["event"] == "finished" and isinstance(event.get("row"), dict)}

        for fmt in ("json", "markdown"):

            report = self.invoke("report", "--format", fmt)

            self.assertEqual(report.returncode, 0, report.stdout + report.stderr)

        summary = json.loads(self.invoke("report").stdout)

        pair = summary["groups"][0]["paired_comparisons"][0]

        if len(set(classes.values())) > 1 and all(event["row"]["success"] for event in self.events()

                                                   if event["event"] == "finished" and isinstance(event.get("row"), dict)):

            self.assertTrue(pair["comparison_refused"], (classes, pair))

            self.assertIn("workflow_integrity_evidence_class", pair["incompatible_evidence_fields"])

            self.assertIn("paired_evidence_incompatible", summary["claim_ineligibility_reasons"])

    def test_corrupted_cache_resume_is_preflight_error_preserving_pending(self):

        self.plan()

        first = self.invoke("run", "--limit", "1")

        self.assertEqual(first.returncode, 3, first.stderr)

        journal = (self.campaign / "events.jsonl").read_bytes()

        payload = next((self.campaign / "fixtures/wide_config_refactor").glob("services/*/config.toml"))

        payload.chmod(0o600)

        payload.write_text("changed cached initial state")

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)

        self.assertIn("fixture content drift", result.stderr)

        self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)

        status = self.invoke("status")

        self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 1)

    def test_cache_and_record_rewrite_cannot_rebind_prior_trial_input(self):

        import hashlib

        self.plan()

        first = self.invoke("run", "--limit", "1")

        self.assertEqual(first.returncode, 3, first.stderr)

        journal = (self.campaign / "events.jsonl").read_bytes()

        fixture = self.campaign / "fixtures/wide_config_refactor"

        payload = next(fixture.glob("services/*/config.toml"))

        payload.chmod(0o600)

        payload.write_bytes(b"changed baseline plus forged cache record")

        record_path = self.campaign / "fixture-integrity/wide_config_refactor.json"

        record = json.loads(record_path.read_text())

        entry = record["manifest"][payload.relative_to(fixture).as_posix()]

        entry.update(size=len(payload.read_bytes()), sha256=hashlib.sha256(payload.read_bytes()).hexdigest())

        record_path.write_text(json.dumps(record))

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)

        self.assertIn("journal fixture binding", result.stderr)

        self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)

        status = self.invoke("status")

        self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 1)

    def test_incomplete_generation_fails_before_any_admission(self):

        self.plan()

        fixture = self.campaign / "fixtures/wide_config_refactor"

        fixture.mkdir(parents=True)

        (fixture / "partial").write_text("crashed generation")

        result = self.invoke("run")

        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)

        self.assertIn("fixture cache is incomplete", result.stderr)

        self.assertFalse((self.campaign / "events.jsonl").exists())

        status = self.invoke("status")

        self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 2)

    def test_existing_plan_and_changed_config_fail_before_agent_execution(self):

        self.plan()

        frozen = (self.campaign / "plan.json").read_bytes()

        result = self.invoke("plan", "--manifest", str(self.manifest))

        self.assertNotEqual(result.returncode, 0)

        self.assertEqual((self.campaign / "plan.json").read_bytes(), frozen)

        self.agents.write_text(self.agents.read_text() + "\n# changed configuration\n")

        result = self.invoke("run")

        self.assertNotEqual(result.returncode, 0)

        self.assertFalse((self.campaign / "events.jsonl").exists())

    def test_torn_journal_cannot_be_discarded_to_retry_a_trial(self):

        plan = self.plan()

        started = {"event": "started", "trial_id": plan["schedule"][0]["trial_id"],

                   "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,

                   "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z",

                   "fixture_manifest_sha256": self.fixture_hash(plan)}

        journal = json.dumps(started).encode() + b"\n" + b'{"event":"finished"'

        (self.campaign / "events.jsonl").write_bytes(journal)

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 2)

        self.assertIn("--acknowledge-torn-journal", result.stderr)

        self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)

        self.assertFalse((self.campaign / "trials").exists())

    def test_impossible_budget_is_rejected_before_frozen_plan(self):

        manifest = json.loads(self.manifest.read_text())

        manifest["max_wall_seconds"] = 0.15

        self.manifest.write_text(json.dumps(manifest))

        result = self.invoke("plan", "--manifest", str(self.manifest))

        self.assertEqual(result.returncode, 2, result.stdout + result.stderr)

        self.assertIn("must admit at least one", result.stderr)

        self.assertFalse(self.campaign.exists())

    def test_remaining_budget_stops_without_shortening_timeout(self):

        plan = self.plan()

        started = {"event": "started", "trial_id": plan["schedule"][0]["trial_id"],

                   "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,

                   "fixture_manifest_sha256": self.fixture_hash(plan)}

        finished = {**started, "event": "finished", "outcome": "error", "wall_seconds": 179.85}

        (self.campaign / "events.jsonl").write_text(json.dumps(started) + "\n" + json.dumps(finished) + "\n")

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 3, result.stdout + result.stderr)

        state = json.loads(result.stdout)

        self.assertEqual(state["stopped_reason"], "insufficient_budget_for_frozen_trial_timeout")

        self.assertEqual(len(state["pending_trial_ids"]), 1)

        self.assertEqual(len(self.events()), 2)

    def test_torn_start_readonly_and_acknowledged_recovery_never_retries(self):

        plan = self.plan()

        interrupted = plan["schedule"][0]["trial_id"]

        raw = b'{"event":"started","trial_id":'

        journal = self.campaign / "events.jsonl"

        journal.write_bytes(raw)

        for command in ("status", "report"):

            result = self.invoke(command)

            self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

            evidence = json.loads(result.stdout)

            self.assertFalse(evidence["journal_recoveries"][0]["acknowledged"])

            self.assertEqual(journal.read_bytes(), raw)

        result = self.invoke("resume", "--acknowledge-torn-journal")

        self.assertEqual(result.returncode, 3, result.stdout + result.stderr)

        events = self.events()

        self.assertEqual(events[0]["trial_id"], interrupted)

        self.assertTrue(events[0]["uncertain_torn_start"])

        marker = events[1]

        self.assertTrue(marker["acknowledged"])

        self.assertEqual((self.campaign / marker["archive"]).read_bytes(), raw)

        self.assertFalse((self.campaign / "trials" / interrupted).exists())

        self.assertEqual(len([e for e in events if e["event"] == "finished"]), 1)

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 3, result.stdout + result.stderr)

        self.assertEqual(self.events(), events)

    def test_valid_digest_malformed_plan_exits_contract_error(self):

        import hashlib

        self.campaign.mkdir()

        malformed = {"schema_version": 1}

        malformed["plan_sha256"] = hashlib.sha256(b'{"schema_version":1}').hexdigest()

        (self.campaign / "plan.json").write_text(json.dumps(malformed))

        result = self.invoke("status")

        self.assertEqual(result.returncode, 2)

        self.assertIn("invalid frozen plan", result.stderr)

        self.assertNotIn("Traceback", result.stderr)

    def test_bounded_invocation_resumes_only_remaining_trial(self):

        self.plan()

        result = self.invoke("run", "--limit", "1")

        self.assertEqual(result.returncode, 3, result.stdout + result.stderr)

        first = self.events()

        self.assertEqual(len(first), 2)

        self.assertTrue(first[1]["row"]["success"], first[1])

        result = self.invoke("resume", "--limit", "1")

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        self.assertEqual(self.events()[:2], first)

        self.assertEqual(len(self.events()), 4)

    def test_interrupted_attempt_stays_visible_after_remaining_trial_runs(self):

        plan = self.plan()

        interrupted = plan["schedule"][0]["trial_id"]

        started = {"event": "started", "trial_id": interrupted,

                   "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,

                   "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z",

                   "fixture_manifest_sha256": self.fixture_hash(plan)}

        (self.campaign / "events.jsonl").write_text(json.dumps(started) + "\n")

        result = self.invoke("resume")

        self.assertEqual(result.returncode, 3, result.stdout + result.stderr)

        events = self.events()

        self.assertEqual(len(events), 3)

        self.assertEqual(events[0], started)

        self.assertNotEqual(events[-1]["trial_id"], interrupted)

        self.assertTrue(events[-1]["row"]["success"], events[-1])

        self.assertFalse((self.campaign / "trials" / interrupted).exists())

        result = self.invoke("report", "--format", "json")

        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)

        counts = json.loads(result.stdout)["counts"]

        self.assertEqual((counts["started"], counts["success"], counts["interrupted"]), (2, 1, 1))

if __name__ == "__main__":

    unittest.main()