"""Production-order controls for isolated output correctness diagnostics."""

from pathlib import Path

import shutil

import sys

import tempfile

import unittest

from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))

import bench

from oakbench import conformance

from oakbench.conformance import tree_manifest

from oakbench.output_semantics import information_recall_fields

@unittest.skipUnless(shutil.which('git'), 'Git control required')

class CoreOracleSequenceTest(unittest.TestCase):

    def test_diagnostic_io_follows_timed_snapshot_chain(self):

        with tempfile.TemporaryDirectory() as temporary:

            root = Path(temporary)

            scenario = bench.Scenario('oracle_order', 2, 80, 2, False, 1)

            fixture = bench.ensure_fixture(root / 'fixtures', scenario)

            subject = bench.Subject('git', 'git', 'Git', Path(shutil.which('git')))

            events = []

            command = bench.run_command

            apply = bench.oakbench_semantics.patch_application_fields

            def recorded_command(*args, **kwargs):

                events.append(args[2])

                return command(*args, **kwargs)

            def recorded_apply(*args, **kwargs):

                events.append('patch-oracle')

                return apply(*args, **kwargs)

            def recorded_manifest(*args, **kwargs):

                events.append('manifest-oracle')

                return tree_manifest(*args, **kwargs)

            with mock.patch.object(bench, 'run_command', side_effect=recorded_command), mock.patch.object(bench.oakbench_semantics, 'patch_application_fields', side_effect=recorded_apply), mock.patch.object(conformance, 'tree_manifest', side_effect=recorded_manifest):

                rows = bench.run_subject_scenario(subject, scenario, fixture, 0, root / 'runs', {}, False, 10000, 'core-equivalent', skip_remote=True)

            self.assertGreater(events.index('patch-oracle'), events.index('task.snapshot.commit'))

            self.assertGreater(events.index('manifest-oracle'), events.index('task.snapshot.commit'))

            self.assertGreater(events.index('diff.dirty'), events.index('task.snapshot.commit'))

            probe = next(row for row in rows if row['operation'] == 'diff.full.inforecall')

            self.assertIsNone(probe['elapsed_ms'])

            self.assertEqual(probe['measurement_phase'], 'output_diagnostic')

            timed_diff = next(row for row in rows if row['operation'] == 'diff.dirty')

            self.assertEqual(timed_diff['cache_state'], 'hash_warmed_isolated_dirty_replay')

            self.assertTrue(probe['patch_apply_ok'])

    def test_failed_diff_mutation_never_reaches_later_same_repo_command(self):

        for returncode in (0, 3):

            with self.subTest(returncode=returncode), tempfile.TemporaryDirectory() as temporary:

                root = Path(temporary)

                scenario = bench.Scenario('mutating_diff', 2, 80, 2, False, 1)

                fixture = bench.ensure_fixture(root / 'fixtures', scenario)

                wrapper = root / 'mutating-git'

                wrapper.write_text('#!' + sys.executable + '\n' +

                    'import pathlib, subprocess, sys\n' +

                    'if sys.argv[1] == "diff":\n' +

                    '    pathlib.Path("collateral").write_text("unexpected")\n' +

                    f'    sys.exit({returncode})\n' +

                    f'sys.exit(subprocess.call([{shutil.which("git")!r}, *sys.argv[1:]]))\n')

                wrapper.chmod(0o755)

                subject = bench.Subject('git', 'git', 'Git', wrapper)

                original = bench.run_command

                poisoned = set()

                def command(*args, **kwargs):

                    cwd = args[3]

                    self.assertNotIn(cwd, poisoned, 'measurement executed after diff corrupted this repository')

                    row = original(*args, **kwargs)

                    if args[2] == 'diff.dirty':

                        self.assertTrue((cwd / 'collateral').exists())

                        poisoned.add(cwd)

                    return row

                with mock.patch.object(bench, 'run_command', side_effect=command):

                    rows = bench.run_subject_scenario(subject, scenario, fixture, 0, root / 'runs', {}, False, 10000, 'core-equivalent', skip_remote=True)

                diff = next(row for row in rows if row['operation'] == 'diff.dirty')

                self.assertEqual(diff['patch_failure_reason'], 'diff_mutated_subject_tree')

                self.assertEqual(diff['returncode'], 1)

                self.assertFalse(diff.get('skipped', False))

                self.assertTrue(any(row['operation'] == 'task.snapshot' for row in rows))

                self.assertFalse(any(row['operation'] == 'diff.full.inforecall' and not row.get('skipped') for row in rows))

    def test_failed_information_diff_is_measured_mutation_not_skip(self):

        with tempfile.TemporaryDirectory() as temporary:

            root = Path(temporary)

            (root / 'a').write_text('original')

            subject = bench.Subject('git', 'git', 'Git', Path(shutil.which('git')))

            command = [sys.executable, '-c', 'import pathlib,sys; pathlib.Path("a").write_text("corrupt"); sys.exit(3)']

            row = bench.run_information_probe(subject, bench.Scenario('mutating_info', 1, 8, 1, False, 1),

                    'diff.full', root, command, 0, {}, ['a'], root)

            self.assertEqual(row['process_returncode'], 3)

            self.assertEqual(row['patch_failure_reason'], 'diff_mutated_subject_tree')

            self.assertFalse(row['patch_apply_ok'])

            self.assertNotIn('patch_skip_reason', row)

            self.assertIsNone(row['elapsed_ms'])

    def test_truncated_path_metrics_are_unmeasured(self):

        fields = information_recall_fields(' M a\n', ['a', 'b'], 100, True, 'status')

        for name in ('information_recall', 'information_precision', 'bytes_per_changed_file_named', 'changed_files_recovered', 'changed_files_reported', 'changed_files_false_positive'):

            self.assertIsNone(fields[name], name)

    def test_main_prerequisite_failure_stops_all_following_operations(self):

        for failed_op in ('repo.init', 'snapshot.initial.add', 'snapshot.initial.commit',

                          'status.clean', 'status.dirty', 'snapshot.dirty.commit', 'branch.create', 'task.snapshot.commit'):

            with self.subTest(operation=failed_op), tempfile.TemporaryDirectory() as temporary:

                root = Path(temporary)

                scenario = bench.Scenario('prerequisite', 2, 80, 2, False, 1)

                fixture = bench.ensure_fixture(root / 'fixtures', scenario)

                subject = bench.Subject('git', 'git', 'Git', Path(shutil.which('git')))

                called = []

                original = bench.run_command

                def command(*args, **kwargs):

                    self.assertNotIn(failed_op, called, 'command after a failed prerequisite')

                    called.append(args[2])

                    row = original(*args, **kwargs)

                    if args[2] == failed_op:

                        row['returncode'] = 3

                    return row

                with mock.patch.object(bench, 'run_command', side_effect=command):

                    rows = bench.run_subject_scenario(subject, scenario, fixture, 0, root / 'runs', {}, False, 10000, 'core-equivalent', skip_remote=True)

                self.assertIn(failed_op, called)

                self.assertTrue(any(row['returncode'] != 0 for row in rows))

                # Abandoned operations are recorded skips, never missing rows.

                failed_main = failed_op.rsplit('.', 1)[0] if failed_op.endswith(('.add', '.commit')) else failed_op

                planned = bench.planned_operations(subject, skip_remote=True, skip_diff=False, skip_determinism_probe=False)

                abandoned = planned[planned.index(failed_main) + 1:]

                skipped = {row['operation']: row for row in rows if row.get('skipped')}

                for op in abandoned:

                    self.assertIn(op, skipped, (failed_op, op))

                    self.assertEqual(skipped[op]['returncode'], 77)

                    self.assertEqual(skipped[op]['skip_reason'], 'aborted_after_failed_prerequisite:' + failed_main)

    def test_branch_failed_attestation_stops_even_with_zero_exit(self):

        with tempfile.TemporaryDirectory() as temporary:

            root = Path(temporary)

            scenario = bench.Scenario('branch_attestation', 2, 80, 2, False, 1)

            fixture = bench.ensure_fixture(root / 'fixtures', scenario)

            subject = bench.Subject('git', 'git', 'Git', Path(shutil.which('git')))

            original = bench.apply_state_change_attestation

            def attest(row, repo, before, operation, **kwargs):

                if operation == 'branch.create':

                    row.update(returncode=0, integrity_check_passed=False)

                    return row

                return original(row, repo, before, operation, **kwargs)

            with mock.patch.object(bench, 'apply_state_change_attestation', side_effect=attest):

                rows = bench.run_subject_scenario(subject, scenario, fixture, 0, root / 'runs', {}, False, 10000, 'core-equivalent', skip_remote=True)

            measured = [row for row in rows if not row.get('skipped')]

            self.assertEqual(measured[-1]['operation'], 'branch.create')

            tail = rows[rows.index(measured[-1]) + 1:]

            self.assertEqual([row['operation'] for row in tail][:1], ['task.snapshot'])

            self.assertTrue(all(row['skip_reason'] == 'aborted_after_failed_prerequisite:branch.create' for row in tail))

    def test_replay_setup_failure_still_stops_fsmonitor(self):

        import subprocess

        with tempfile.TemporaryDirectory() as temporary:

            root = Path(temporary)

            scenario = bench.Scenario('setup_cleanup', 1, 80, 1, False, 1)

            fixture = bench.ensure_fixture(root / 'fixtures', scenario)

            subject = bench.Subject('git_fsmonitor', 'git', 'Git', Path('/git'), git_mode='fsmonitor')

            calls = []

            def command(args, **kwargs):

                calls.append(args)

                return subprocess.CompletedProcess(args, 3 if 'add' in args else 0, b'', b'failed')

            with mock.patch.object(bench.subprocess, 'run', side_effect=command):

                rows = bench.run_isolated_dirty_phase(subject, scenario, fixture, 0, root / 'runs', {}, False, 10000, 'core-equivalent', False)

            self.assertEqual(rows[0]['returncode'], 77)

            self.assertEqual(calls[-1], ['/git', 'fsmonitor--daemon', 'stop'])

    def test_determinism_first_failure_cannot_be_overwritten_by_second_success(self):

        with tempfile.TemporaryDirectory() as temporary:

            root = Path(temporary)

            script = 'import pathlib,sys; p=pathlib.Path("attempt"); first=not p.exists(); p.touch(); sys.exit(3 if first else 0)'

            subject = bench.Subject('git', 'git', 'Git', Path(shutil.which('git')))

            row = bench.run_determinism_probe(subject, bench.Scenario('repeat', 1, 8, 1, False, 1),

                'status.dirty', root, [sys.executable, '-c', script], 0, {})

            self.assertEqual(row['returncode'], 3)

            self.assertIsNone(row['output_stable'])