# SPDX-License-Identifier: AGPL-3.0-or-later
"""Phase 4: the recursive arms route every decomposition through the planning
pilot's scripted provider.

The scripted provider at the pilot seam, the routing, and the replay evidence
(docs/research/phase4-recursive-planning-integration-provider-brief.md). Every
test here runs a real trial through the committed harness, so the module is
slow-marked: the fast suite and the project oracle's internal fast gate
deselect it, and the acceptance command names it explicitly.
"""
from __future__ import annotations

import dataclasses
import os
from typing import Any, Dict, List, Mapping, Sequence

import pytest

from helpers import experiment_authorization
from orchestrator import experiment, oracle, planning_pilot, sandbox, spend, trial_driver
from orchestrator.store import EventStore

pytestmark = [pytest.mark.slow, pytest.mark.timeout(2400)]

_SEED = 1001
_ROUTED_ARMS = (experiment.ARM_RECURSIVE_LAZY, experiment.ARM_RECURSIVE_CONCURRENT)
_PROBE_ARM = experiment.ARM_RECURSIVE_LAZY
_PROBE_SEED = 2001
#: The scripted default profile, captured at import — before any test can mutate
#: the delegated ``experiment.MODEL_PROFILE`` binding — so this module's trials do
#: not read a profile an earlier module leaked (F5). The routing shapes must hold
#: under the sanctioned full-suite module ordering, not only when run alone.
_PINNED_PROFILE = experiment.MODEL_PROFILE


def _decomposition_events(events) -> List[Any]:
    return [event for event in events if event.event_type == "DECOMPOSITION_ADMITTED"]


def _expected_coverage(children: Sequence[Mapping[str, Any]]) -> List[Dict[str, Any]]:
    return [
        {
            "child_id": child["node_id"],
            "criterion_id": criterion_id,
            "mandatory_cover": bool(child.get("mandatory")),
        }
        for child in children
        for criterion_id in child.get("criterion_ids", ())
    ]


def _refusing_provider(state: Any, parent_node_id: str) -> List[Dict[str, Any]]:
    """A provider whose one child escapes its parent's scope.

    It proves the seam is live: the pilot guard refuses it at ``SCOPE``, and the
    driver must not fall back to any other admission path.
    """
    node = state.nodes.get(parent_node_id)
    contract = (node.contract if node is not None else None) or {}
    criteria = [criterion["id"] for criterion in contract.get("acceptance_criteria") or []]
    return [
        {
            "node_id": f"{parent_node_id}-rogue",
            "mandatory": True,
            "criterion_ids": list(criteria),
            "contract": {
                "owned_scope": ["outside/**"],
                "acceptance_criteria": [
                    {"id": criterion, "mandatory": True} for criterion in criteria
                ],
                "budget_id": f"{parent_node_id}-rogue-budget",
            },
            "budget_allocation": {"MODEL_COST": 1.0},
        }
    ]


def _events(workdir: str, arm: str, seed: int, run_id: str) -> List[Any]:
    store = EventStore(os.path.join(workdir, "trials", f"{arm}-{seed}", "events.db"))
    try:
        return list(store.history(run_id))
    finally:
        store.close()


def _nodes(workdir: str, arm: str, seed: int, run_id: str):
    store = EventStore(os.path.join(workdir, "trials", f"{arm}-{seed}", "events.db"))
    try:
        return set(store.state(run_id).nodes)
    finally:
        store.close()


@dataclasses.dataclass
class _RoutedRun:
    workdir: str
    target: Any
    oracle: Any
    ledger: Any
    metrics: Mapping[str, Any]
    calls: Mapping[str, List[Dict[str, Any]]]

    def events(self, arm: str) -> List[Any]:
        return _events(self.workdir, arm, _SEED, self.metrics[arm].run_id)

    def replay(self, arm: str):
        run_id = self.metrics[arm].run_id
        store = EventStore(
            os.path.join(self.workdir, "trials", f"{arm}-{_SEED}", "events.db")
        )
        try:
            return run_id, store.state(run_id), store.replay_fresh(run_id)
        finally:
            store.close()


@dataclasses.dataclass
class _ProbeRun:
    workdir: str
    metrics: Any

    def events(self) -> List[Any]:
        return _events(self.workdir, _PROBE_ARM, _PROBE_SEED, self.metrics.run_id)

    def nodes(self):
        return _nodes(self.workdir, _PROBE_ARM, _PROBE_SEED, self.metrics.run_id)


@pytest.fixture(scope="module")
def routed(tmp_path_factory) -> _RoutedRun:
    capabilities = sandbox.capabilities(refresh=True)
    if not capabilities.profile_available:
        pytest.fail(
            f"NAMESPACE_V1 unavailable (fail-closed gate): "
            f"{capabilities.unavailable_reason()}"
        )
    workdir = str(tmp_path_factory.mktemp("pilot-routing"))
    target = experiment.build_fixed_target(workdir)
    oracle_manifest = experiment.build_hidden_oracle(target)
    ledger = spend.open_spend_ledger(workdir, experiment_authorization())

    calls: Dict[str, List[Dict[str, Any]]] = {}
    original = planning_pilot.propose_decomposition

    def spy(state, parent_node_id, provider, **kwargs):
        payload, record, capability = original(state, parent_node_id, provider, **kwargs)
        calls.setdefault(state.run_id, []).append(
            {"parent": parent_node_id, "payload": payload, "record": record}
        )
        return payload, record, capability

    planning_pilot.propose_decomposition = spy
    # Pin the binding the trials read: the default scripted profile captured at
    # import, and no model-client factory. The module restores what it found.
    previous_factory = experiment.MODEL_CLIENT_FACTORY
    experiment.set_model_client_factory(None)
    metrics: Dict[str, Any] = {}
    try:
        for arm in (
            experiment.ARM_RECURSIVE_LAZY,
            experiment.ARM_RECURSIVE_CONCURRENT,
            experiment.ARM_FIXED_ONE_LEVEL,
            experiment.ARM_DIRECT,
        ):
            metrics[arm] = experiment.run_trial(
                target,
                oracle_manifest,
                experiment.placeholder_limits(),
                _PINNED_PROFILE,
                arm,
                _SEED,
                workdir,
                spend_ledger=ledger,
            )
    finally:
        planning_pilot.propose_decomposition = original
        experiment.set_model_client_factory(previous_factory)
    return _RoutedRun(workdir, target, oracle_manifest, ledger, metrics, calls)


@pytest.fixture(scope="module")
def refusing(routed: _RoutedRun) -> _ProbeRun:
    original = trial_driver._scripted_decomposition_provider
    trial_driver._scripted_decomposition_provider = _refusing_provider
    try:
        metrics = experiment.run_trial(
            routed.target,
            routed.oracle,
            experiment.placeholder_limits(),
            _PINNED_PROFILE,
            _PROBE_ARM,
            _PROBE_SEED,
            routed.workdir,
            spend_ledger=routed.ledger,
        )
    finally:
        trial_driver._scripted_decomposition_provider = original
    return _ProbeRun(routed.workdir, metrics)


# ---------------------------------------------------------------------------
# Routing shape: both recursive arms route through the pilot's scripted
# provider, and every proposal reaches DECOMPOSITION_ADMITTED.
# ---------------------------------------------------------------------------


@pytest.mark.parametrize("arm", _ROUTED_ARMS)
def test_every_recursive_decomposition_routes_through_the_pilot(routed, arm):
    metrics = routed.metrics[arm]
    events = _decomposition_events(routed.events(arm))
    calls = routed.calls[metrics.run_id]
    assert calls, "the recursive arm issued no pilot proposal"
    admitted = [call for call in calls if call["payload"] is not None]
    assert len(events) == 2, "the fixed target nests exactly two levels"
    assert len(admitted) == len(events)
    assert metrics.decomposition_rejections == 0
    assert [call["parent"] for call in admitted] == [
        event.payload["node_id"] for event in events
    ]
    assert all(call["record"]["admitted"] is True for call in calls)


def test_the_routing_seam_refuses_an_escaping_scope(refusing):
    metrics = refusing.metrics
    assert _decomposition_events(refusing.events()) == []
    record = metrics.decomposition_provider_records[0]
    assert record["admitted"] is False
    assert record["refusing_stage"] == "SCOPE"
    assert record["accepted_children"] == 0
    assert metrics.decomposition_rejections == 1
    assert not any("rogue" in node_id for node_id in refusing.nodes())


# ---------------------------------------------------------------------------
# Derived-equivalence shape: the routed structure is the derived structure, and
# DIRECT and FIXED_ONE_LEVEL keep their un-routed observable behaviour.
# ---------------------------------------------------------------------------


@pytest.mark.parametrize("arm", _ROUTED_ARMS)
def test_routed_structure_equals_derived_structure(routed, arm):
    run_id, live, _fresh = routed.replay(arm)
    for event in _decomposition_events(routed.events(arm)):
        parent = event.payload["node_id"]
        expected = trial_driver.plan_decomposition(run_id, live.nodes[parent].contract)
        admitted = event.payload["children"]
        assert [child["node_id"] for child in admitted] == [
            child["node_id"] for child in expected
        ]
        assert [child["contract"]["owned_scope"] for child in admitted] == [
            child["contract"]["owned_scope"] for child in expected
        ]
        assert [child.get("criterion_ids") for child in admitted] == [
            child.get("criterion_ids") for child in expected
        ]
        assert [child["budget_allocation"] for child in admitted] == [
            child["budget_allocation"] for child in expected
        ]
        assert event.payload["criterion_coverage"] == _expected_coverage(expected)
        assert event.payload["dependencies"] == trial_driver._decomposition_dependencies(
            expected
        )


def test_direct_and_fixed_one_level_keep_their_unrouted_behaviour(routed):
    direct = routed.metrics[experiment.ARM_DIRECT]
    assert direct.decomposition_provider_id == "NONE"
    assert direct.decomposition_provider_records == ()
    assert _decomposition_events(routed.events(experiment.ARM_DIRECT)) == []

    fixed = routed.metrics[experiment.ARM_FIXED_ONE_LEVEL]
    assert fixed.decomposition_provider_id == "DERIVED"
    assert fixed.decomposition_provider_records == ()
    fixed_events = _decomposition_events(routed.events(experiment.ARM_FIXED_ONE_LEVEL))
    assert [event.payload["node_id"] for event in fixed_events] == [fixed.run_id + "-root"]
    assert fixed.nodes == 4, "FIXED_ONE_LEVEL must stop after one level"


# ---------------------------------------------------------------------------
# Refusal shape: a pilot refusal is recorded, never logged, and never routed to
# a second admission path.
# ---------------------------------------------------------------------------


def test_a_refused_proposal_is_recorded_and_not_admitted(refusing):
    metrics = refusing.metrics
    assert _decomposition_events(refusing.events()) == []
    records = metrics.decomposition_provider_records
    assert len(records) == 1
    assert records[0]["admitted"] is False
    assert records[0]["refusing_stage"] == "SCOPE"
    assert records[0]["proposed_children"] == 1
    assert records[0]["accepted_children"] == 0
    assert metrics.decomposition_rejections == 1
    # The admission failure propagated as a rejection does: the trial ends
    # unresolved rather than accepting a root that was never decomposed.
    assert metrics.controller_outcome is None
    assert metrics.classification == oracle.TRIAL_CORRECTLY_UNRESOLVED


# ---------------------------------------------------------------------------
# No-mutation shape: nothing edits an admitted payload between the guard and
# event admission; dependencies are supplied through the producer's argument.
# ---------------------------------------------------------------------------


@pytest.mark.parametrize("arm", _ROUTED_ARMS)
def test_admitted_payload_is_forwarded_unmutated(routed, arm):
    metrics = routed.metrics[arm]
    events = _decomposition_events(routed.events(arm))
    admitted = [call for call in routed.calls[metrics.run_id] if call["payload"] is not None]
    assert len(admitted) == len(events)
    for call, event in zip(admitted, events):
        payload = call["payload"]
        assert call["parent"] == event.payload["node_id"]
        assert call["record"]["accepted_children"] == len(event.payload["children"])
        assert payload["criterion_coverage"] == event.payload["criterion_coverage"]
        assert payload["dependencies"] == event.payload["dependencies"]
        for produced, logged in zip(payload["children"], event.payload["children"]):
            assert "deps" not in produced, "dependency edges must not ride in children"
            assert "deps" not in logged
            assert produced["node_id"] == logged["node_id"]
            assert produced["contract"]["owned_scope"] == logged["contract"]["owned_scope"]
            assert produced["contract"]["acceptance_criteria"] == (
                logged["contract"]["acceptance_criteria"]
            )
            assert produced["budget_allocation"] == logged["budget_allocation"]
            # The guard's payload is still pristine after admission: the
            # controller's version pin is applied to its own copy, never to the
            # object the guard returned.
            assert "parent_proposal" not in produced["contract"]
            assert logged["contract"]["parent_proposal"] == payload["proposal_id"]


# ---------------------------------------------------------------------------
# Provider-id shape: every trial records the provider it routed through.
# ---------------------------------------------------------------------------


def test_every_arm_records_its_decomposition_provider_id(routed):
    expected = {
        experiment.ARM_RECURSIVE_LAZY: "SCRIPTED",
        experiment.ARM_RECURSIVE_CONCURRENT: "SCRIPTED",
        experiment.ARM_FIXED_ONE_LEVEL: "DERIVED",
        experiment.ARM_DIRECT: "NONE",
    }
    for arm, provider_id in expected.items():
        metrics = routed.metrics[arm]
        assert metrics.decomposition_provider_id == provider_id
        assert metrics.to_dict()["decomposition_provider_id"] == provider_id
    routing = dict(experiment.METRIC_GROUPS)["routing"]
    assert "decomposition_provider_id" in routing


# ---------------------------------------------------------------------------
# Instrument shape: every routed proposal leaves its record_outcome on the
# trial in proposal order, admitted or refused.
# ---------------------------------------------------------------------------


def test_every_routed_proposal_leaves_its_instrument_in_order(routed, refusing):
    for arm in _ROUTED_ARMS:
        metrics = routed.metrics[arm]
        records = [call["record"] for call in routed.calls[metrics.run_id]]
        assert list(metrics.decomposition_provider_records) == records
        events = _decomposition_events(routed.events(arm))
        admitted = [record for record in records if record["admitted"]]
        for record, event in zip(admitted, events):
            assert record["refusing_stage"] is None
            assert record["accepted_children"] == len(event.payload["children"])
    refused = refusing.metrics.decomposition_provider_records
    assert [record["admitted"] for record in refused] == [False]
    assert refused[0]["refusing_stage"] == "SCOPE"
    assert refused[0]["accepted_children"] == 0
    assert refused[0]["proposed_children"] == 1


# ---------------------------------------------------------------------------
# Replay shape: replay_fresh reproduces the routed structure from the log
# alone, and the instrument's counts agree with the log.
# ---------------------------------------------------------------------------


def test_replay_fresh_reproduces_the_routed_structure(routed):
    for arm in _ROUTED_ARMS:
        run_id, live, fresh = routed.replay(arm)
        assert set(fresh.nodes) == set(live.nodes)
        for node_id, node in fresh.nodes.items():
            assert node.contract == live.nodes[node_id].contract
        live_edges = sorted(
            (relation.from_node_id, relation.to_node_id)
            for relation in live.relations.values()
            if relation.relation_type == "DEPENDS_ON"
        )
        fresh_edges = sorted(
            (relation.from_node_id, relation.to_node_id)
            for relation in fresh.relations.values()
            if relation.relation_type == "DEPENDS_ON"
        )
        assert fresh_edges == live_edges
        live_metadata = {
            relation_id: dict(relation.metadata or {})
            for relation_id, relation in live.relations.items()
            if relation.relation_type == "CHILD_OF"
        }
        fresh_metadata = {
            relation_id: dict(relation.metadata or {})
            for relation_id, relation in fresh.relations.items()
            if relation.relation_type == "CHILD_OF"
        }
        assert fresh_metadata == live_metadata
        records = routed.metrics[arm].decomposition_provider_records
        events = _decomposition_events(routed.events(arm))
        for record, event in zip(records, events):
            assert record["accepted_children"] == len(event.payload["children"])
            logged_children = {child["node_id"] for child in event.payload["children"]}
            assert logged_children <= set(fresh.nodes)
            for coverage in event.payload["criterion_coverage"]:
                assert coverage["child_id"] in logged_children
                relation = next(
                    relation
                    for relation in fresh.relations.values()
                    if relation.relation_type == "CHILD_OF"
                    and relation.from_node_id == coverage["child_id"]
                )
                assert coverage["criterion_id"] in relation.metadata["criterion_ids"]
                assert coverage["mandatory_cover"] == relation.metadata["mandatory"]
