#!/usr/bin/env python3
"""Phase 0 contract and fixture verification tests for Issue #5 (Rev.4).

Validates:
1. Herdr Layer 1 native contract captures (pure native observation, no injected MAM fields).
2. Herdr wait contract options, exit codes, and channel separation (stderr for timeout & not found).
3. 6-backend capability coverage matrix and honest gap tracking.
4. Watcher Layer 2 composite scenarios, 4-fold attribution, timelines, authenticity, and fail-closed policies.
5. Contract cross-checks against baseline.md and herdr-runtime.md.
6. Mutation and negative tests demonstrating that corruption, unrelated references, payload mismatches,
   and dishonest provenance labels are rejected.
"""

import copy
import json
from pathlib import Path
import pytest

REPO_ROOT = Path(__file__).resolve().parent.parent
DOCS_ROOT = REPO_ROOT / "docs" / "contracts" / "issue-5"
FIXTURES_ROOT = REPO_ROOT / "tests" / "fixtures" / "issue_5"
HERDR_ROOT = FIXTURES_ROOT / "herdr"
WATCHER_ROOT = FIXTURES_ROOT / "watcher"

FORBIDDEN_MAM_KEYS = {
    "job_id",
    "attempt_id",
    "report_phase",
    "report_path",
    "expected_decision",
    "stable_candidate",
    "manifest_hash",
}


# ===========================================================================
# Validation Engine Functions (Used for both real fixtures & negative tests)
# ===========================================================================

def validate_native_capture(cap: dict, file_path: Path = None) -> None:
    """Strictly validates a native Herdr capture envelope and channel payloads."""
    assert cap.get("schema_version") == "1.0.0", "Invalid schema_version"
    assert cap.get("herdr_version") == "0.8.2", "Invalid herdr_version"
    assert cap.get("provenance") == "observed", "Native capture provenance must be 'observed'"
    assert "command_argv" in cap and isinstance(cap["command_argv"], list), "command_argv must be list"
    assert "exit_code" in cap and isinstance(cap["exit_code"], int), "exit_code must be int"
    assert "capture_id" in cap, "capture_id required"

    exit_code = cap["exit_code"]
    stdout_payload = cap.get("stdout_payload")
    stderr_raw = cap.get("stderr")

    # Channel separation invariant
    if exit_code == 0:
        assert stdout_payload is not None, "exit 0 must provide stdout_payload"
        assert stderr_raw is None, "exit 0 must have null stderr"
        payload_to_check = stdout_payload
    else:
        assert stdout_payload is None, "nonzero exit must have null stdout_payload"
        assert stderr_raw is not None and isinstance(stderr_raw, str), "nonzero exit must have string stderr"
        try:
            payload_to_check = json.loads(stderr_raw)
        except Exception as exc:
            raise AssertionError(f"stderr for nonzero exit must be valid JSON: {exc}")

    # Payload duplicate check (if present, must match channel payload)
    if "payload" in cap and cap["payload"] is not None:
        assert cap["payload"] == payload_to_check, "Top-level payload duplicate does not match channel payload"

    # Enforce zero MAM orchestration injection
    def _check_no_forbidden(obj, prefix=""):
        if isinstance(obj, dict):
            for k, v in obj.items():
                assert k not in FORBIDDEN_MAM_KEYS, (
                    f"Forbidden MAM field '{k}' injected into native capture payload at {prefix}{k}"
                )
                _check_no_forbidden(v, prefix=f"{prefix}{k}.")
        elif isinstance(obj, list):
            for i, elem in enumerate(obj):
                _check_no_forbidden(elem, prefix=f"{prefix}[{i}].")

    _check_no_forbidden(payload_to_check)


def validate_watcher_scenario(data: dict, file_path: Path = None) -> None:
    """Strictly validates a Watcher composite scenario, attribution, timeline authenticity, and correspondence."""
    assert data.get("schema_version") == "1.0.0", "Invalid schema_version"
    assert "scenario_id" in data, "scenario_id required"
    assert "description" in data, "description required"
    assert "filesystem" in data, "filesystem required"
    assert "expected_policy" in data, "expected_policy required"
    assert "dispatch_context" in data, "dispatch_context required"
    assert "timeline" in data and isinstance(data["timeline"], list), "timeline must be list"

    overall_prov = data.get("provenance")
    assert overall_prov in {"observed_composite", "simulated", "mixed"}, f"Invalid overall provenance: {overall_prov}"

    # 4-Fold Attribution verification
    dctx = data["dispatch_context"]
    for req_attr in ("job_id", "attempt_id", "agent_session_uuid", "pane_process_generation"):
        assert req_attr in dctx, f"Missing attribution field in dispatch_context: '{req_attr}'"
        assert dctx[req_attr] is not None and dctx[req_attr] != "", (
            f"Attribution field '{req_attr}' must not be null or empty in dispatch_context"
        )
    assert "execution_anchor_observed" in dctx, "execution_anchor_observed boolean required"

    # Expected Policy verification
    policy = data["expected_policy"]
    assert policy.get("decision") in {
        "hold",
        "hold_blocked",
        "hold_reconnect",
        "reject_stale",
        "candidate_approved",
    }, f"Invalid expected policy decision: {policy.get('decision')}"
    assert policy.get("reason"), "expected_policy.reason must not be empty"

    # Timeline authenticity & correspondence
    observed_count = 0
    simulated_count = 0
    total_items = len(data["timeline"])
    assert total_items > 0, "timeline must contain at least one item"

    for i, item in enumerate(data["timeline"]):
        item_prov = item.get("source_provenance")
        assert item_prov in {"observed", "simulated", "synthetic"}, f"Invalid source_provenance: {item_prov}"

        if item_prov == "observed":
            observed_count += 1
            assert "capture_ref" in item and item["capture_ref"], (
                f"Timeline item [{i}] is marked observed but lacks non-empty 'capture_ref'"
            )
            ref_path = REPO_ROOT / item["capture_ref"]
            assert ref_path.exists(), f"Observed timeline item [{i}] points to nonexistent capture_ref: {ref_path}"
            assert ref_path.suffix == ".json", f"capture_ref must point to a JSON evidence record, got {ref_path}"

            # Authenticity check: load and verify evidence record
            try:
                ref_data = json.loads(ref_path.read_text(encoding="utf-8"))
            except Exception as exc:
                raise AssertionError(f"capture_ref {ref_path} must be valid JSON: {exc}")

            assert ref_data.get("schema_version") == "1.0.0", f"capture_ref {ref_path} missing schema_version 1.0.0"
            assert ref_data.get("provenance") == "observed", f"capture_ref {ref_path} must have provenance 'observed'"
            assert "capture_id" in ref_data, f"capture_ref {ref_path} missing capture_id"

            # Source correspondence check
            source_kind = item.get("source_kind")
            if source_kind == "herdr":
                assert "backend" in ref_data or "herdr_version" in ref_data, (
                    f"capture_ref {ref_path} for herdr source must be a native Herdr capture"
                )
                item_payload = item.get("payload", {})
                if "agent_status" in item_payload:
                    ref_status = None
                    payload_obj = ref_data.get("stdout_payload") or ref_data.get("payload") or {}
                    if isinstance(payload_obj, dict):
                        if "result" in payload_obj and isinstance(payload_obj["result"], dict):
                            ag = payload_obj["result"].get("agent", {})
                            if isinstance(ag, dict):
                                ref_status = ag.get("agent_status")
                        if not ref_status and "agent_status" in payload_obj:
                            ref_status = payload_obj["agent_status"]
                    assert ref_status == item_payload["agent_status"], (
                        f"Payload correspondence mismatch: timeline specifies agent_status='{item_payload['agent_status']}' "
                        f"but capture {ref_path} records agent_status='{ref_status}'"
                    )
        else:
            simulated_count += 1

    # Provenance honesty invariant
    if observed_count > 0 and simulated_count > 0:
        assert overall_prov == "mixed", (
            f"Scenario has both observed ({observed_count}) and simulated ({simulated_count}) timeline items; "
            f"overall provenance must be 'mixed', got '{overall_prov}'"
        )
    elif observed_count == total_items:
        assert overall_prov == "observed_composite", (
            f"All timeline items are observed; overall provenance must be 'observed_composite', got '{overall_prov}'"
        )
    elif simulated_count == total_items:
        assert overall_prov == "simulated", (
            f"All timeline items are simulated; overall provenance must be 'simulated', got '{overall_prov}'"
        )


# ===========================================================================
# 1. Layer 1 — Herdr Native Contract Fixture Tests
# ===========================================================================

def test_herdr_wait_contract_schema_and_channels():
    contract_file = HERDR_ROOT / "wait-contract.json"
    assert contract_file.exists(), "wait-contract.json must exist"
    data = json.loads(contract_file.read_text(encoding="utf-8"))

    assert data["schema_version"] == "1.0.0"
    assert data["herdr_version"] == "0.8.2"
    assert "--until" in data["options"]
    assert "--timeout" in data["options"]

    outcomes = {o["outcome"]: o for o in data["call_outcomes"]}
    assert "state_matched" in outcomes
    assert "timeout" in outcomes
    assert "agent_not_found" in outcomes

    # Invariant: exit codes
    assert outcomes["state_matched"]["exit_code"] == 0
    assert outcomes["timeout"]["exit_code"] != 0
    assert outcomes["agent_not_found"]["exit_code"] != 0

    # Invariant: output channels (both timeout and agent_not_found output to stderr)
    assert outcomes["state_matched"]["output_channel"] == "stdout"
    assert outcomes["timeout"]["output_channel"] == "stderr", "Herdr wait timeout must output to stderr"
    assert outcomes["agent_not_found"]["output_channel"] == "stderr", "Herdr wait not-found must output to stderr"


def test_herdr_manifest_covers_all_six_backends():
    manifest_file = HERDR_ROOT / "manifest.json"
    assert manifest_file.exists(), "herdr manifest.json must exist"
    manifest = json.loads(manifest_file.read_text(encoding="utf-8"))

    expected_backends = {"claude", "agy", "hermes", "grok", "opencode", "codex"}
    actual_backends = set(manifest["backends"].keys())
    assert actual_backends == expected_backends, f"Expected 6 backends: {expected_backends}"

    for backend, bdata in manifest["backends"].items():
        assert "installed_binary" in bdata
        assert "slots" in bdata
        for slot_name, slot in bdata["slots"].items():
            if slot["status"] == "observed":
                target_file = HERDR_ROOT / slot["file"]
                assert target_file.exists(), f"Observed slot {backend}/{slot_name} missing file: {target_file}"
            elif slot["status"] == "unobserved":
                assert slot.get("reason"), f"Unobserved slot {backend}/{slot_name} must state an honest reason"


def test_native_herdr_captures_strictly_exclude_orchestration_injection():
    capture_files = list(HERDR_ROOT.glob("*/*.json"))
    assert len(capture_files) >= 4, f"Expected at least 4 native captures, found {len(capture_files)}"

    for cap_path in capture_files:
        cap = json.loads(cap_path.read_text(encoding="utf-8"))
        validate_native_capture(cap, file_path=cap_path)


# ===========================================================================
# 2. Layer 2 — Watcher Composite Scenario Tests
# ===========================================================================

def test_watcher_manifest_and_all_seven_scenarios_exist():
    manifest_file = WATCHER_ROOT / "manifest.json"
    assert manifest_file.exists(), "watcher manifest.json must exist"
    manifest = json.loads(manifest_file.read_text(encoding="utf-8"))

    expected_scenarios = {
        "initial_idle",
        "tool_running",
        "report_pause_15s",
        "finalized_candidate",
        "blocked_permission",
        "transport_disconnected",
        "restarted_generation",
    }
    actual_scenarios = set(manifest["scenarios"].keys())
    assert actual_scenarios == expected_scenarios, f"Mismatch in watcher scenarios: {actual_scenarios}"

    for sid, sinfo in manifest["scenarios"].items():
        sfile = WATCHER_ROOT / sinfo["file"]
        assert sfile.exists(), f"Scenario file for {sid} missing: {sfile}"


def test_watcher_composite_scenario_structures():
    for sfile in WATCHER_ROOT.glob("*.json"):
        if sfile.name == "manifest.json":
            continue
        data = json.loads(sfile.read_text(encoding="utf-8"))
        validate_watcher_scenario(data, file_path=sfile)


# ===========================================================================
# 3. Document Alignment Tests (Guards against Prose Inversions F1/F2)
# ===========================================================================

def test_documents_align_with_runtime_and_cli_contracts():
    """Asserts that baseline.md and herdr-runtime.md do not invert CLI precedence or timeout channels."""
    baseline_text = (DOCS_ROOT / "baseline.md").read_text(encoding="utf-8")
    runtime_text = (DOCS_ROOT / "herdr-runtime.md").read_text(encoding="utf-8")

    # F1 Guard: baseline.md must specify --all-reviewer takes precedence over --reviewer
    assert "--all-reviewer" in baseline_text
    assert "run_loop.sh:64, 192-196" in baseline_text
    assert "--all-reviewer`가 우선" in baseline_text or "--all-reviewer takes precedence" in baseline_text
    assert "`0`을 허용" in baseline_text, "--plan-talk must document regex accepting 0"

    # F2 Guard: herdr-runtime.md must document timeout output channel as stderr
    assert "타임아웃" in runtime_text
    assert "`stderr`" in runtime_text, "herdr-runtime.md must state timeout JSON is on stderr"


def test_mutation_policy_invariants():
    """Ensures fail-closed invariants for target CAS state machine."""
    # 1. initial_idle must HOLD because execution anchor is missing
    init_idle = json.loads((WATCHER_ROOT / "initial_idle.json").read_text(encoding="utf-8"))
    assert init_idle["dispatch_context"]["execution_anchor_observed"] is False
    assert init_idle["expected_policy"]["decision"] == "hold"

    # 2. tool_running must HOLD because tool is active
    tool_run = json.loads((WATCHER_ROOT / "tool_running.json").read_text(encoding="utf-8"))
    assert tool_run["expected_policy"]["decision"] == "hold"

    # 3. report_pause_15s must HOLD because commit manifest is absent
    pause = json.loads((WATCHER_ROOT / "report_pause_15s.json").read_text(encoding="utf-8"))
    assert pause["filesystem"]["manifest_committed"] is False
    assert pause["expected_policy"]["decision"] == "hold"

    # 4. finalized_candidate alone approves completion
    finalized = json.loads((WATCHER_ROOT / "finalized_candidate.json").read_text(encoding="utf-8"))
    assert finalized["dispatch_context"]["execution_anchor_observed"] is True
    assert finalized["filesystem"]["manifest_committed"] is True
    assert finalized["filesystem"]["hash_verified"] is True
    assert finalized["expected_policy"]["decision"] == "candidate_approved"

    # 5. restarted_generation must REJECT stale attempt
    restarted = json.loads((WATCHER_ROOT / "restarted_generation.json").read_text(encoding="utf-8"))
    assert restarted["expected_policy"]["decision"] == "reject_stale"


# ===========================================================================
# 4. Negative / Mutation Tests (Evidence Boundary & Corruption Rejection)
# ===========================================================================

def test_negative_native_capture_with_injected_mam_field_fails():
    sample_file = HERDR_ROOT / "claude" / "idle.json"
    cap = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(cap)
    corrupted["stdout_payload"]["result"]["agent"]["report_phase"] = "writing"
    corrupted["payload"]["result"]["agent"]["report_phase"] = "writing"
    with pytest.raises(AssertionError, match="Forbidden MAM field 'report_phase'"):
        validate_native_capture(corrupted)


def test_negative_native_capture_channel_exit_code_mismatch_fails():
    sample_file = HERDR_ROOT / "claude" / "idle.json"
    cap = json.loads(sample_file.read_text(encoding="utf-8"))

    # exit 0 with non-null stderr must fail
    corrupted = copy.deepcopy(cap)
    corrupted["stderr"] = "some error"
    with pytest.raises(AssertionError, match="exit 0 must have null stderr"):
        validate_native_capture(corrupted)


def test_negative_watcher_missing_session_uuid_fails():
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    del corrupted["dispatch_context"]["agent_session_uuid"]
    with pytest.raises(AssertionError, match="Missing attribution field"):
        validate_watcher_scenario(corrupted)

    corrupted2 = copy.deepcopy(sc)
    corrupted2["dispatch_context"]["agent_session_uuid"] = None
    with pytest.raises(AssertionError, match="must not be null"):
        validate_watcher_scenario(corrupted2)


def test_negative_watcher_simulated_labeled_observed_composite_fails():
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    corrupted["provenance"] = "observed_composite"
    # Timeline has simulated items, so labeling as observed_composite must fail
    with pytest.raises(AssertionError, match="overall provenance must be 'simulated'"):
        validate_watcher_scenario(corrupted)


def test_negative_watcher_observed_item_with_missing_capture_ref_fails():
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    corrupted["timeline"][0]["source_provenance"] = "observed"
    corrupted["timeline"][0]["capture_ref"] = "nonexistent/capture/path.json"
    with pytest.raises(AssertionError, match="points to nonexistent capture_ref"):
        validate_watcher_scenario(corrupted)


def test_negative_watcher_observed_item_pointing_to_unrelated_file_fails():
    """P1: Pointing an observed timeline reference to an existing unrelated file (e.g. README.md) must fail."""
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    corrupted["provenance"] = "observed_composite"
    for item in corrupted["timeline"]:
        item["source_provenance"] = "observed"
        item["capture_ref"] = "README.md"
    with pytest.raises(AssertionError, match="JSON evidence record"):
        validate_watcher_scenario(corrupted)


def test_negative_watcher_observed_item_with_mismatched_payload_fails():
    """P1: Referencing a valid capture with a mismatched payload state must fail."""
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    corrupted["timeline"][0]["source_kind"] = "herdr"
    corrupted["timeline"][0]["source_provenance"] = "observed"
    # Points to claude/idle.json (which records agent_status='idle')
    corrupted["timeline"][0]["capture_ref"] = "tests/fixtures/issue_5/herdr/claude/idle.json"
    corrupted["timeline"][0]["payload"] = {"agent_status": "working"}  # Mismatch!
    with pytest.raises(AssertionError, match="Payload correspondence mismatch"):
        validate_watcher_scenario(corrupted)


def test_negative_watcher_coexisting_sources_labeled_simulated_fails():
    """P1: Coexistence of observed and simulated sources must be labeled 'mixed', not 'simulated'."""
    sample_file = WATCHER_ROOT / "initial_idle.json"
    sc = json.loads(sample_file.read_text(encoding="utf-8"))

    corrupted = copy.deepcopy(sc)
    corrupted["provenance"] = "simulated"  # Dishonest! Should be mixed
    corrupted["timeline"][0]["source_kind"] = "herdr"
    corrupted["timeline"][0]["source_provenance"] = "observed"
    corrupted["timeline"][0]["capture_ref"] = "tests/fixtures/issue_5/herdr/claude/idle.json"
    corrupted["timeline"][0]["payload"] = {"agent_status": "idle"}
    # timeline[1] remains simulated
    with pytest.raises(AssertionError, match="overall provenance must be 'mixed'"):
        validate_watcher_scenario(corrupted)