# SPDX-License-Identifier: AGPL-3.0-or-later
"""A3 seeded ledger-operation fuzzer.

A seeded sequence of ``reserve``, ``commit_reservation``, ``settle``,
``reclaim_reservation``, and ``transfer`` operations is applied to a two-level
budget, checking the ledger invariants after every step. Refusals
(``OvercommitmentError``, ``LedgerStateError``) are expected and are checked
too, because a refused operation must not leave inconsistent state.

Anti-vacuity: every sequence contains at least one settle and one transfer, and
the invariants are shown to be falsifiable by an injected violating sequence.
"""
from __future__ import annotations

import random

import pytest

from orchestrator.model import (
    BudgetRecord,
    Ledger,
    LedgerEntry,
    OvercommitmentError,
    TOLERANCE,
)

from ledger_invariants import (
    LEDGER_INVARIANTS,
    assert_ledger_invariants,
    collect_ledger_violations,
    no_overcommitment,
)

DIMENSION = "MODEL_COST"
SEEDS = tuple(range(8))
STEPS = 40
REFUSALS = (OvercommitmentError,)


def _fresh_ledger() -> Ledger:
    ledger = Ledger()
    ledger.register_budget(BudgetRecord("root", "root-node", {DIMENSION: 20.0}))
    ledger.register_budget(
        BudgetRecord("child", "child-node", {DIMENSION: 10.0}, parent_budget_id="root")
    )
    return ledger


def _walk(seed: int, steps: int) -> Ledger:
    rng = random.Random(seed)
    ledger = _fresh_ledger()
    reserved = {}
    committed = {}
    counter = 0
    saw_settle = saw_transfer = False

    # Deterministic prefix so every sequence has both a settle and a transfer.
    for budget, amount in (("child", 2.0), ("root", 1.0)):
        counter += 1
        attempt = f"a{counter}"
        ledger.reserve(f"e-{attempt}", budget, amount, DIMENSION, attempt, ledger.budgets[budget].node_id)
        reserved[attempt] = (budget, amount)
    prefix_attempt = "a1"
    ledger.commit_reservation(prefix_attempt, reserved[prefix_attempt][1], DIMENSION)
    committed[prefix_attempt] = reserved.pop(prefix_attempt)[1]
    ledger.settle(prefix_attempt, 2.0, 0.0)
    committed.pop(prefix_attempt)
    saw_settle = True
    ledger.transfer("root", "child", {DIMENSION: 1.0})
    saw_transfer = True
    assert_ledger_invariants(ledger)

    for _ in range(steps):
        operation = rng.choice(["reserve", "commit", "settle", "reclaim", "transfer"])
        try:
            if operation == "reserve":
                counter += 1
                attempt = f"a{counter}"
                budget = rng.choice(["root", "child"])
                amount = rng.choice([0.5, 1.0, 2.0, 5.0, 10.0])
                ledger.reserve(
                    f"e-{attempt}", budget, amount, DIMENSION, attempt, ledger.budgets[budget].node_id
                )
                reserved[attempt] = (budget, amount)
            elif operation == "commit" and reserved:
                attempt = rng.choice(sorted(reserved))
                _budget, amount = reserved.pop(attempt)
                ledger.commit_reservation(attempt, amount, DIMENSION)
                committed[attempt] = amount
            elif operation == "settle" and committed:
                attempt = rng.choice(sorted(committed))
                commitment = committed.pop(attempt)
                actual = max(0.0, commitment + rng.choice([-0.5, 0.0, 0.5, 1.0, 3.0]))
                ledger.settle(attempt, actual, max(0.0, commitment - actual))
                saw_settle = True
            elif operation == "reclaim" and reserved:
                attempt = rng.choice(sorted(reserved))
                reserved.pop(attempt)
                ledger.reclaim_reservation(attempt)
            elif operation == "transfer":
                amount = rng.choice([0.5, 1.0, 2.0, 5.0])
                source, target = rng.choice([("root", "child"), ("child", "root")])
                ledger.transfer(source, target, {DIMENSION: amount})
                saw_transfer = True
        except REFUSALS:
            pass
        assert_ledger_invariants(ledger)

    assert saw_settle, "anti-vacuity: the sequence must contain a settle"
    assert saw_transfer, "anti-vacuity: the sequence must contain a transfer"
    return ledger


@pytest.mark.parametrize("seed", SEEDS)
def test_seeded_ledger_sequences_preserve_invariants(seed):
    ledger = _walk(seed, STEPS)
    # The walk must have done real work, not only refusals.
    assert ledger.total_charged > 0.0


@pytest.mark.slow
@pytest.mark.parametrize("seed", SEEDS[:4])
def test_large_budget_ledger_sequences_preserve_invariants(seed):
    """Slow tier: the same walk under a larger step budget."""
    ledger = _walk(seed, STEPS * 10)
    assert ledger.total_charged > 0.0


def test_invariants_are_falsifiable():
    """A hand-injected over-commitment must be detected, proving the invariant
    is not vacuous."""
    ledger = _fresh_ledger()
    ledger.entries["injected"] = LedgerEntry(
        entry_id="injected",
        budget_id="child",
        ancestor_budget_path=("root", "child"),
        kind="RESERVATION",
        dimension=DIMENSION,
        amount=1000.0,
        attempt_id="ghost",
        node_id="child-node",
        active=True,
    )
    assert no_overcommitment(ledger)
    assert "no_overcommitment" in collect_ledger_violations(ledger)


def test_every_invariant_is_exercised_by_the_walk():
    """The walk must be rich enough to touch each invariant's domain."""
    _walk(seed=0, steps=STEPS)
    assert len(LEDGER_INVARIANTS) == 4
