# SPDX-License-Identifier: AGPL-3.0-or-later
"""A7 spend-path coverage meta-test.

``tests/spend_paths.yaml`` must register every public entry point that can
spend. This test fails if a known path is removed, if an entry does not resolve
to a callable, or if the registry drifts from the pinned set of entry points.
"""
from __future__ import annotations

import importlib
import os

import yaml

PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
REGISTRY_PATH = os.path.join(PROJECT_ROOT, "tests", "spend_paths.yaml")

REQUIRED_SPEND_PATHS = frozenset(
    {
        ("orchestrator.controller", "Controller.plan_attempt"),
        ("orchestrator.controller", "Controller.dispatch_attempt"),
        ("orchestrator.controller", "Controller.execute_attempt"),
        ("orchestrator.controller", "Controller.schedule_child_attempts"),
        ("orchestrator.controller", "Controller.run_model_review"),
        ("orchestrator.controller", "Controller.replace_root"),
        ("orchestrator.experiment", "run_trial"),
        ("orchestrator.experiment", "run_pilots"),
        ("orchestrator.experiment", "run_measured_comparison"),
        ("orchestrator.experiment", "run_experiment"),
        ("orchestrator.experiment", "calibrate_oracle"),
    }
)
LEDGERS = frozenset({"run_ledger", "experiment_ledger", "none"})


def _load() -> list[dict]:
    with open(REGISTRY_PATH) as handle:
        return yaml.safe_load(handle)["spend_paths"]


def _resolve(module: str, qualname: str):
    obj = importlib.import_module(module)
    for part in qualname.split("."):
        obj = getattr(obj, part)
    return obj


def test_registry_covers_every_known_spend_path():
    registered = {(entry["module"], entry["qualname"]) for entry in _load()}
    assert registered == REQUIRED_SPEND_PATHS, (
        f"spend-path registry drift: missing={sorted(REQUIRED_SPEND_PATHS - registered)} "
        f"unexpected={sorted(registered - REQUIRED_SPEND_PATHS)}"
    )


def test_every_spend_path_resolves_and_declares_a_ledger():
    for entry in _load():
        assert callable(_resolve(entry["module"], entry["qualname"])), (
            f"{entry['module']}.{entry['qualname']} is not callable"
        )
        assert entry["reserves"] in LEDGERS, f"{entry['qualname']} has an unknown ledger"
        assert entry.get("reason"), f"{entry['qualname']} has no rationale"


def test_both_ledgers_and_the_no_spend_class_are_represented():
    reserves = {entry["reserves"] for entry in _load()}
    assert reserves == LEDGERS, f"registry does not cover every ledger class: {sorted(reserves)}"
