"""Step 9 load-bearing seam (SC7): assessment-method encoding — a PERSISTED dimension-scoped
example (Arm A) + an INDEPENDENT deterministic validator rule (Arm B).

Arm A (navigable, dimension-scoped): the persisted, MAF-repo-local method bundle
(``data/method_examples/energi/``) carries a ``type: methodology`` file with ``dimension: energi``.
Its sentinel reaches ``bundle_context(..., dimension="energi")`` but is ABSENT at
``dimension="asfalt"`` — the detach is the Step-3 dimension filter (H4: "text is rendered" is not a
detachable seam on its own; the dimension SCOPING is).

Arm B (independent validator rule): a proposal the generic P90 stage PASSES but the stricter energy-
method cap REJECTS — proving the method rule is an INDEPENDENT gate (not redundant with P90). Detach
the rule (or flip the measure) and the same proposal validates. The rule returns the validator's own
``Rejection`` type, so the validator stays the sole blocking gate and provenance stays honest (the
numbers only).

Patterns: ``test_okf.py:141/51`` (navigable + bundle_context), ``test_validator.py:49`` (rule).
"""

from __future__ import annotations

from pathlib import Path

from portfolio_optimiser import okf
from portfolio_optimiser.ir import AffectedItem, SavingsProposal
from portfolio_optimiser.validator import (
    Rejection,
    ValidatedProposal,
    validate_proposal,
)

METHOD_BUNDLE = (
    Path(__file__).resolve().parents[1]
    / "src"
    / "portfolio_optimiser"
    / "data"
    / "method_examples"
    / "energi"
)
_METHOD_SENTINEL = "ENERGI-METODE-IPMVP-A-SENTINEL"


# --- Arm A: navigable, dimension-scoped persisted example ----------------------------------------


def test_persisted_method_navigable_when_dimension_matches() -> None:
    """The persisted energi method (``dimension: energi``) is navigable + rendered when the run is
    scoped to energi — an actually-delivered, persisted '>=1 encoded method' (not an ephemeral copy)."""
    bundle = okf.navigate_bundle(str(METHOD_BUNDLE))
    scoped = okf.bundle_context(bundle, dimension="energi")
    assert _METHOD_SENTINEL in scoped


def test_persisted_method_absent_for_other_dimension() -> None:
    """LOAD-BEARING (SC7-A): the energi method is ABSENT when the run is scoped to another dimension.
    RED if the Step-3 dimension filter is detached (the energi method then leaks into an asfalt run)."""
    bundle = okf.navigate_bundle(str(METHOD_BUNDLE))
    other = okf.bundle_context(bundle, dimension="asfalt")
    assert _METHOD_SENTINEL not in other


# --- Arm B: independent deterministic validator rule ---------------------------------------------


def _proposal(measure: str, claimed: float) -> SavingsProposal:
    """Affected total 100000 (degenerate MC, empty assumptions) -> generic P90 = 0.30 x 100000 =
    30000; the energy-method cap = 0.15 x 100000 = 15000."""
    return SavingsProposal(
        project_id="P-ENERGI",
        measure=measure,
        affected_items=[AffectedItem(code="ENERGI-TOTAL-EL", quantity=100000, unit_cost=1.0)],
        claimed_saving_nok=claimed,
        assumptions={},
    )


def test_method_rule_is_independent_of_generic_p90() -> None:
    """LOAD-BEARING (SC7-B): claimed 20000 is <= generic P90 (30000) but > the energy-method cap
    (15000). A NON-energy proposal with the same numbers validates (P90 passes); the energy-method
    proposal is REJECTED by the stricter method rule — an independent flip. RED if the method rule is
    detached (the energy proposal then validates too)."""
    # Control: same numbers, non-energy measure -> the generic P90 stage validates it.
    control = validate_proposal(_proposal("scope_reduction", 20000))
    assert isinstance(control, ValidatedProposal), (
        "the generic P90 stage should pass 20000 <= 30000"
    )

    # Energy method: the stricter method cap flips the SAME numbers to a Rejection.
    result = validate_proposal(_proposal("energy_efficiency", 20000))
    assert isinstance(result, Rejection), "the energy-method cap must reject a P90-valid over-claim"
    assert "method cap" in result.reason
    # The rule returns the validator's OWN Rejection type -> the validator stays the sole blocking
    # gate (numbers only); it never introduces a new gate type.


def test_method_rule_admits_within_the_stricter_cap() -> None:
    """Causality control: an energy proposal WITHIN the method cap (claimed 15000 == 0.15 x 100000)
    validates — proving the rejection above is caused by exceeding the cap, not the measure string."""
    result = validate_proposal(_proposal("energy_efficiency", 15000))
    assert isinstance(result, ValidatedProposal)