"""
Exhaustive CWM tests — every exchange mechanic, every edge case.

Test categories:
  1. Tick/lot rounding
  2. Price-time priority + sequential level consumption
  3. Partial fills across multiple levels
  4. Post-only rejection (buy crosses ask, sell crosses bid)
  5. CROSS_SPREAD immediate fill
  6. Cancel order
  7. Cancel-replace
  8. Fee application (maker vs taker)
  9. Position update (open, add, reduce, close)
  10. Mark-to-market
  11. Realized PnL on sell
  12. Available balance deduction
  13. Path-state update (entry, MAE, MFE, recovery)
  14. Counterparty fills consuming book levels
  15. Empty book handling
  16. Determinism (same input = same output)
  17. Input immutability
  18. Timestamp advancement
  19. Edge cases (zero qty, zero price, negative equity)
"""
import math
import pytest
from malkhut.state import (
    AccountState, ExecutionIntent, FulfilmentPolicyParams, IntentKind,
    MarketWorldState, Mode, OpenOrderState, OrderBookState, PositionState,
    PriceLevel, Side, TradePathState, VenueRules,
)
from malkhut.cwm.core import (
    MinimalCryptoLOBCWM, materialize_price_from_action,
    _round_tick, _round_lot, _clip_lots, _fill_from_levels,
)
from malkhut.actions import ActionKind, CounterpartyAction, AgentRole, FulfilmentAction, OrderType


# ── Helpers ──────────────────────────────────────────────────────────────────

def _venue(**kw):
    d = dict(exchange="bingx", symbol="BTCUSDT", tick_size=0.1, lot_size=0.001,
             min_qty=0.001, min_notional=5.0, maker_fee_bps=-0.2, taker_fee_bps=0.5,
             post_only_supported=True, reduce_only_supported=True,
             max_orders_per_second=100, max_cancels_per_minute=120)
    d.update(kw)
    return VenueRules(**d)


def _book(bid=50000.0, ask=50001.0, bid_qty=1.0, ask_qty=1.0, ts=1_000_000_000, **kw):
    bids = kw.get("bids", ((bid, bid_qty),))
    asks = kw.get("asks", ((ask, ask_qty),))
    return OrderBookState(
        ts_ns=ts, symbol="BTCUSDT",
        bids=tuple(PriceLevel(p, q) for p, q in bids),
        asks=tuple(PriceLevel(p, q) for p, q in asks),
    )


def _account(equity=10000.0, **kw):
    return AccountState(
        ts_ns=kw.get("ts", 1_000_000_000), equity=equity,
        wallet_balance=kw.get("wallet", equity),
        available_balance=kw.get("available", equity),
        margin_used=kw.get("margin", 0.0),
        total_notional=kw.get("notional", 0.0),
        positions=kw.get("positions", {}),
    )


def _state(bid=50000.0, ask=50001.0, equity=10000.0, **kw):
    return MarketWorldState(
        ts_ns=kw.get("ts", 1_000_000_000), mode=Mode.REPLAY_NO_IMPACT,
        venue=kw.get("venue", _venue()),
        book=_book(bid, ask, bid_qty=kw.get("bid_qty", 1.0), ask_qty=kw.get("ask_qty", 1.0)),
        account=_account(equity, positions=kw.get("positions", {})),
        open_orders=kw.get("open_orders", ()),
        trade_path=kw.get("trade_path"), intent=kw.get("intent"),
    )


def _noop():
    return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)


def _place(side, offset=0, frac=0.1, post_only=False, reduce_only=False):
    return FulfilmentAction(
        ActionKind.PLACE, side,
        OrderType.POST_ONLY if post_only else OrderType.LIMIT,
        offset, frac, 200,
        post_only=post_only, reduce_only=reduce_only,
    )


def _cross(side, frac=0.1):
    return FulfilmentAction(ActionKind.CROSS_SPREAD, side, OrderType.IOC, 0, frac, 50)


def _cancel(order_id):
    return FulfilmentAction(ActionKind.CANCEL, Side.BUY, None, 0, 0.0, 0, cancel_order_id=order_id)


def _oo(cid="c1", price=50000.0, qty=0.001, side=Side.BUY, ts=1_000_000_000):
    return OpenOrderState(
        client_order_id=cid, venue_order_id="v1", symbol="BTCUSDT",
        side=side, order_type=OrderType.POST_ONLY, price=price,
        qty=qty, remaining_qty=qty, queue_ahead_estimate=qty * 0.5,
        created_ts_ns=ts, last_update_ts_ns=ts, post_only=True,
    )


def _tp(side=Side.BUY, pnl=0.0, mae=-10.0, mfe=5.0, ts=1_000_000_000,
        failed_recovery_count=0):
    return TradePathState(
        symbol="BTCUSDT", side=side, entry_ts_ns=ts, now_ts_ns=ts,
        bars_held=5, seconds_held=50.0, pnl_bps=pnl, mae_bps=mae,
        mfe_bps=mfe, distance_from_mfe_bps=mfe - pnl,
        distance_from_entry_bps=abs(pnl), time_to_mfe_s=20.0,
        time_in_loss_s=30.0, time_in_profit_s=20.0,
        time_since_last_profit_s=5.0, time_since_deep_mae_s=10.0,
        loss_to_profit_transitions=1, deep_loss_recoveries=0,
        failed_recovery_count=failed_recovery_count,
        recovery_velocity_bps_per_s=1.0,
        adverse_velocity_bps_per_s=-0.5,
        dolphin_regime_score=0.5, jericho_signal_strength=0.3,
        volatility_bps=15.0, orderflow_toxicity=0.3,
        queue_churn_score=0.2, book_imbalance=0.1, cross_venue_lead_score=0.1,
    )


# ══════════════════════════════════════════════════════════════════════════════
# 1. TICK / LOT ROUNDING
# ══════════════════════════════════════════════════════════════════════════════

class TestTickRounding:
    def test_round_tick_exact(self):
        assert _round_tick(50000.0, 0.1) == 50000.0

    def test_round_tick_up(self):
        assert _round_tick(50000.06, 0.1) == pytest.approx(50000.1, abs=1e-9)

    def test_round_tick_down(self):
        assert _round_tick(50000.04, 0.1) == 50000.0

    def test_round_tick_tiny_tick(self):
        assert _round_tick(50000.055, 0.01) == 50000.06

    def test_round_tick_large_tick(self):
        assert _round_tick(50005.0, 1.0) == 50005.0

    def test_round_tick_large_tick_rounds_down(self):
        # round(50004.9 / 1.0) = round(50004.9) = 50005 (banker's rounds to even)
        assert _round_tick(50004.4, 1.0) == 50004.0


class TestLotRounding:
    def test_round_lot_exact(self):
        assert _round_lot(0.001, 0.001) == 0.001

    def test_round_lot_up(self):
        assert _round_lot(0.0015, 0.001) == 0.002

    def test_round_lot_down(self):
        assert _round_lot(0.0014, 0.001) == 0.001

    def test_round_lot_large_lot(self):
        assert _round_lot(1.5, 1.0) == 2.0


class TestClipLots:
    def test_clip_above_min(self):
        assert _clip_lots(0.005, 0.001, 0.001) == 0.005

    def test_clip_below_min_returns_zero(self):
        assert _clip_lots(0.0005, 0.001, 0.001) == 0.0

    def test_clip_exact_min(self):
        assert _clip_lots(0.001, 0.001, 0.001) == 0.001

    def test_clip_rounds_to_lot(self):
        assert _clip_lots(0.0017, 0.001, 0.001) == 0.002

    def test_clip_zero_qty(self):
        assert _clip_lots(0.0, 0.001, 0.001) == 0.0


# ══════════════════════════════════════════════════════════════════════════════
# 2. FILL FROM LEVELS (price-time priority)
# ══════════════════════════════════════════════════════════════════════════════

class TestFillFromLevels:
    def test_fill_single_level_full(self):
        levels = [PriceLevel(50000.0, 1.0)]
        filled, avg, remaining = _fill_from_levels(levels, 0.5, 0.001, 0.001)
        assert filled == 0.5
        assert avg == 50000.0
        assert len(remaining) == 1
        assert remaining[0].qty == 0.5

    def test_fill_single_level_exact(self):
        levels = [PriceLevel(50000.0, 1.0)]
        filled, avg, remaining = _fill_from_levels(levels, 1.0, 0.001, 0.001)
        assert filled == 1.0
        assert len(remaining) == 0

    def test_fill_multi_level(self):
        levels = [PriceLevel(50000.0, 0.5), PriceLevel(50001.0, 0.5)]
        filled, avg, remaining = _fill_from_levels(levels, 0.8, 0.001, 0.001)
        assert filled == 0.8
        assert abs(avg - (50000.0 * 0.5 + 50001.0 * 0.3) / 0.8) < 0.01
        assert len(remaining) == 1
        assert remaining[0].price == 50001.0
        assert remaining[0].qty == 0.2

    def test_fill_exhausts_all_levels(self):
        levels = [PriceLevel(50000.0, 0.3), PriceLevel(50001.0, 0.3)]
        filled, avg, remaining = _fill_from_levels(levels, 1.0, 0.001, 0.001)
        assert filled == 0.6
        assert len(remaining) == 0

    def test_fill_empty_levels(self):
        filled, avg, remaining = _fill_from_levels([], 1.0, 0.001, 0.001)
        assert filled == 0.0
        assert remaining == []

    def test_fill_preserves_price_order(self):
        levels = [PriceLevel(50001.0, 0.5), PriceLevel(50000.0, 0.5)]
        filled, avg, remaining = _fill_from_levels(levels, 0.3, 0.001, 0.001)
        # Should fill from 50001.0 first (first in list = highest priority)
        assert avg == 50001.0

    def test_fill_lot_rounding(self):
        levels = [PriceLevel(50000.0, 1.0)]
        filled, avg, remaining = _fill_from_levels(levels, 0.555, 0.1, 0.1)
        assert filled == pytest.approx(0.6, abs=0.01)  # rounded to 0.1 lot

    def test_fill_below_min_qty(self):
        levels = [PriceLevel(50000.0, 1.0)]
        filled, avg, remaining = _fill_from_levels(levels, 0.0005, 0.001, 0.001)
        assert filled == 0.0

    def test_fill_three_levels(self):
        levels = [
            PriceLevel(50000.0, 0.1),
            PriceLevel(50001.0, 0.1),
            PriceLevel(50002.0, 0.1),
        ]
        filled, avg, remaining = _fill_from_levels(levels, 0.25, 0.001, 0.001)
        assert filled == 0.25
        assert avg == (50000.0 * 0.1 + 50001.0 * 0.1 + 50002.0 * 0.05) / 0.25
        assert len(remaining) == 1
        assert remaining[0].price == 50002.0
        assert remaining[0].qty == pytest.approx(0.05, abs=0.001)


# ══════════════════════════════════════════════════════════════════════════════
# 3. POST-ONLY REJECTION
# ══════════════════════════════════════════════════════════════════════════════

class TestPostOnlyRejection:
    def test_buy_at_ask_rejected(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=-10, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert r.account.equity == s.account.equity
        assert len(r.open_orders) == len(s.open_orders)

    def test_sell_at_bid_rejected(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.SELL, offset=-10, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert r.account.equity == s.account.equity

    def test_buy_inside_spread_accepted(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=0, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert any(o.side == Side.BUY for o in r.open_orders)

    def test_sell_inside_spread_accepted(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.SELL, offset=0, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert any(o.side == Side.SELL for o in r.open_orders)

    def test_buy_one_tick_below_ask_accepted(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(bid=50000.0, ask=50001.0)
        # price = 50000.0 - (-9)*0.1 = 50000.9 < 50001.0
        a = _place(Side.BUY, offset=-9, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert any(o.side == Side.BUY for o in r.open_orders)

    def test_sell_one_tick_above_bid_accepted(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(bid=50000.0, ask=50001.0)
        # price = 50001.0 + (-9)*0.1 = 50000.1 > 50000.0
        a = _place(Side.SELL, offset=-9, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert any(o.side == Side.SELL for o in r.open_orders)

    def test_wide_spread_allows_more_offsets(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(bid=49000.0, ask=51000.0)
        # price = 49000.0 - (-10)*0.1 = 49001.0 < 51000.0
        a = _place(Side.BUY, offset=-10, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert any(o.side == Side.BUY for o in r.open_orders)


# ══════════════════════════════════════════════════════════════════════════════
# 4. CROSS_SPREAD (immediate fill)
# ══════════════════════════════════════════════════════════════════════════════

class TestCrossSpread:
    def test_cross_buy_fills(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.account.equity < s.account.equity

    def test_cross_sell_fills(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.SELL, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.account.equity <= s.account.equity

    def test_cross_buy_updates_book(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(ask=50001.0, ask_qty=1.0)
        a = _cross(Side.BUY, frac=0.5)
        r = cwm.transition(s, (a,))
        # Ask should be reduced
        total_ask_qty = sum(l.qty for l in r.book.asks)
        assert total_ask_qty < 1.0

    def test_cross_buy_fills_at_best_ask(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.book.last_trade_price == 50001.0

    def test_cross_sell_fills_at_best_bid(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.SELL, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.book.last_trade_price == 50000.0

    def test_cross_partial_fill(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(ask_qty=0.002)
        a = _cross(Side.BUY, frac=0.5)  # wants more than available
        r = cwm.transition(s, (a,))
        # Should fill what's available
        assert r.account.equity < s.account.equity

    def test_cross_consumes_levels_sequentially(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(asks=((50001.0, 0.1), (50002.0, 0.1)))
        a = _cross(Side.BUY, frac=0.5)
        r = cwm.transition(s, (a,))
        # Should consume from 50001 first, then 50002
        assert r.book.last_trade_price <= 50002.0

    def test_cross_creates_position(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        pos = r.account.positions.get("BTCUSDT")
        assert pos is not None
        assert pos.qty > 0

    def test_cross_no_fill_when_zero_qty(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.0)
        r = cwm.transition(s, (a,))
        assert r.account.equity == s.account.equity

    def test_cross_updates_last_trade(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.book.last_trade_side == Side.BUY
        assert r.book.last_trade_qty > 0


# ══════════════════════════════════════════════════════════════════════════════
# 5. CANCEL ORDER
# ══════════════════════════════════════════════════════════════════════════════

class TestCancelOrder:
    def test_cancel_removes_order(self):
        oo = _oo("c1")
        cwm = MinimalCryptoLOBCWM()
        s = _state(open_orders=(oo,))
        a = _cancel("c1")
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 0

    def test_cancel_wrong_id_keeps_order(self):
        oo = _oo("c1")
        cwm = MinimalCryptoLOBCWM()
        s = _state(open_orders=(oo,))
        a = _cancel("wrong")
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 1

    def test_cancel_only_one_order(self):
        oo1 = _oo("c1")
        oo2 = _oo("c2")
        cwm = MinimalCryptoLOBCWM()
        s = _state(open_orders=(oo1, oo2))
        a = _cancel("c1")
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 1
        assert r.open_orders[0].client_order_id == "c2"

    def test_cancel_nonexistent_id(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(open_orders=(_oo("c1"),))
        a = _cancel("nonexistent")
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 1

    def test_cancel_empty_book(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cancel("c1")
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 0


# ══════════════════════════════════════════════════════════════════════════════
# 6. PASSIVE PLACEMENT
# ══════════════════════════════════════════════════════════════════════════════

class TestPassivePlacement:
    def test_passive_buy_added(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 1
        assert r.open_orders[0].side == Side.BUY

    def test_passive_sell_added(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.SELL, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert len(r.open_orders) == 1
        assert r.open_orders[0].side == Side.SELL

    def test_passive_price_correct(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        assert r.open_orders[0].price == 49999.9

    def test_passive_qty_correct(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        expected_qty = 0.1 * 10000.0 / 49999.9
        assert r.open_orders[0].qty > 0

    def test_passive_order_id_unique(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a1 = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r1 = cwm.transition(s, (a1,))
        # Use r1 as input (different ts_ns) for second order
        a2 = _place(Side.BUY, offset=2, frac=0.1, post_only=True)
        r2 = cwm.transition(r1, (a2,))
        assert r1.open_orders[0].client_order_id != r2.open_orders[-1].client_order_id

    def test_multiple_passive_orders(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        a2 = _place(Side.BUY, offset=2, frac=0.1, post_only=True)
        r2 = cwm.transition(r, (a2,))
        assert len(r2.open_orders) == 2

    def test_passive_no_position_change(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _place(Side.BUY, offset=1, frac=0.1, post_only=True)
        r = cwm.transition(s, (a,))
        pos = r.account.positions.get("BTCUSDT")
        assert pos is None or pos.qty == 0


# ══════════════════════════════════════════════════════════════════════════════
# 7. FEES
# ══════════════════════════════════════════════════════════════════════════════

class TestFeeApplication:
    def test_taker_fee_reduces_equity(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        fee = 0.001 * 50001.0 * 0.5 / 10_000  # taker fee
        assert r.account.equity < s.account.equity

    def test_maker_fee_rebate(self):
        """Counterparty fill should not charge us taker fees."""
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        cp = CounterpartyAction(
            AgentRole.TOXIC_TAKER, ActionKind.CROSS_SPREAD, Side.BUY, 0, 0.1, toxicity=0.8,
        )
        r = cwm.transition(s, (_noop(), cp))
        # CP fill touches book but doesn't go through our fee path
        # available_balance should be reduced (position opened via maker fill)
        assert r.account.available_balance <= s.account.available_balance


# ══════════════════════════════════════════════════════════════════════════════
# 8. POSITION UPDATE
# ══════════════════════════════════════════════════════════════════════════════

class TestPositionUpdate:
    def test_open_long_position(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        pos = r.account.positions.get("BTCUSDT")
        assert pos is not None
        assert pos.qty > 0
        assert pos.side == Side.BUY

    def test_open_short_position(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.SELL, frac=0.1)
        r = cwm.transition(s, (a,))
        pos = r.account.positions.get("BTCUSDT")
        assert pos is not None
        assert pos.qty < 0
        assert pos.side == Side.SELL

    def test_add_to_long(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.01, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.05, side=Side.BUY,
        )
        s = _state(positions={"BTCUSDT": pos})
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        new_pos = r.account.positions.get("BTCUSDT")
        assert new_pos.qty > 0.01

    def test_reduce_long(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.1, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.5, side=Side.BUY,
        )
        s = _state(positions={"BTCUSDT": pos})
        a = _cross(Side.SELL, frac=0.1)
        r = cwm.transition(s, (a,))
        new_pos = r.account.positions.get("BTCUSDT")
        assert new_pos.qty < 0.1

    def test_avg_entry_updates_on_add(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.01, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.05, side=Side.BUY,
        )
        s = _state(bid=49000.0, ask=49001.0, positions={"BTCUSDT": pos})
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        new_pos = r.account.positions.get("BTCUSDT")
        assert new_pos.avg_entry != 50000.0

    def test_realized_pnl_on_reduce(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.1, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.5, side=Side.BUY,
        )
        s = _state(bid=51000.0, ask=51001.0, positions={"BTCUSDT": pos})
        a = _cross(Side.SELL, frac=0.1)
        r = cwm.transition(s, (a,))
        new_pos = r.account.positions.get("BTCUSDT")
        assert new_pos.realized_pnl > 0

    def test_no_position_no_change(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _noop()
        r = cwm.transition(s, (a,))
        assert "BTCUSDT" not in r.account.positions

    def test_leverage_calculation(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.5)
        r = cwm.transition(s, (a,))
        pos = r.account.positions.get("BTCUSDT")
        assert pos.leverage > 0


# ══════════════════════════════════════════════════════════════════════════════
# 9. MARK-TO-MARKET
# ══════════════════════════════════════════════════════════════════════════════

class TestMarkToMarket:
    def test_mtM_updates_on_fill(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.1, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.5, side=Side.BUY,
        )
        # Large book so CP doesn't empty it
        s = _state(bid=51000.0, ask=51001.0, ask_qty=10.0, positions={"BTCUSDT": pos})
        a = _cross(Side.BUY, frac=0.5)
        r = cwm.transition(s, (a,))
        new_pos = r.account.positions.get("BTCUSDT")
        assert new_pos is not None
        assert new_pos.qty > 0.1

    def test_mtM_equity_changes_on_fill(self):
        cwm = MinimalCryptoLOBCWM()
        pos = PositionState(
            symbol="BTCUSDT", qty=0.1, avg_entry=50000.0,
            unrealized_pnl=0.0, realized_pnl=0.0,
            liquidation_price=None, leverage=0.5, side=Side.BUY,
        )
        s = _state(bid=51000.0, ask=51001.0, ask_qty=10.0, positions={"BTCUSDT": pos})
        a = _cross(Side.BUY, frac=0.5)
        r = cwm.transition(s, (a,))
        assert r.account.equity != s.account.equity


# ══════════════════════════════════════════════════════════════════════════════
# 10. PATH-STATE UPDATE
# ══════════════════════════════════════════════════════════════════════════════

class TestPathStateUpdate:
    def test_new_position_creates_path(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.trade_path is not None
        assert r.trade_path.side == Side.BUY

    def test_path_entry_timestamp(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.trade_path.entry_ts_ns == r.ts_ns

    def test_path_pnl_updates(self):
        cwm = MinimalCryptoLOBCWM()
        path = _tp(side=Side.BUY, pnl=0.0, mae=-5.0, mfe=10.0)
        s = _state(trade_path=path)
        a = _noop()
        r = cwm.transition(s, (a,))
        assert r.trade_path is not None

    def test_path_mae_tracking(self):
        cwm = MinimalCryptoLOBCWM()
        path = _tp(side=Side.BUY, mae=-20.0)
        s = _state(trade_path=path)
        a = _noop()
        r = cwm.transition(s, (a,))
        assert r.trade_path.mae_bps <= -20.0

    def test_path_mfe_tracking(self):
        cwm = MinimalCryptoLOBCWM()
        path = _tp(side=Side.BUY, mfe=15.0)
        s = _state(trade_path=path)
        a = _noop()
        r = cwm.transition(s, (a,))
        assert r.trade_path.mfe_bps >= 15.0


# ══════════════════════════════════════════════════════════════════════════════
# 11. COUNTERPARTY FILLS
# ══════════════════════════════════════════════════════════════════════════════

class TestCounterpartyFills:
    def test_cp_buy_consumes_asks(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(asks=((50001.0, 0.5),))
        # fraction=5.0 means cp wants to buy 5.0 * 10000 / 50001 = ~1.0 units
        # Should consume all 0.5 from top level
        cp = CounterpartyAction(
            AgentRole.TOXIC_TAKER, ActionKind.CROSS_SPREAD, Side.BUY, 0, 5.0, toxicity=0.8,
        )
        r = cwm.transition(s, (_noop(), cp))
        total_ask = sum(l.qty for l in r.book.asks)
        assert total_ask < 0.5  # consumed from top level

    def test_cp_sell_consumes_bids(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(bids=((50000.0, 0.5),))
        cp = CounterpartyAction(
            AgentRole.TOXIC_TAKER, ActionKind.CROSS_SPREAD, Side.SELL, 0, 5.0, toxicity=0.8,
        )
        r = cwm.transition(s, (_noop(), cp))
        total_bid = sum(l.qty for l in r.book.bids)
        assert total_bid < 0.5  # consumed from top level

    def test_cp_fill_updates_book(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(asks=((50001.0, 0.1), (50002.0, 0.1)))
        cp = CounterpartyAction(
            AgentRole.TOXIC_TAKER, ActionKind.CROSS_SPREAD, Side.BUY, 0, 0.5, toxicity=0.8,
        )
        r = cwm.transition(s, (_noop(), cp))
        assert r.book.last_trade_price is not None

    def test_cp_fill_reduces_available(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        cp = CounterpartyAction(
            AgentRole.NOISE_TRADER, ActionKind.CROSS_SPREAD, Side.BUY, 0, 0.1, toxicity=0.1,
        )
        r = cwm.transition(s, (_noop(), cp))
        assert r.account.available_balance <= s.account.available_balance


# ══════════════════════════════════════════════════════════════════════════════
# 12. DETERMINISM
# ══════════════════════════════════════════════════════════════════════════════

class TestDeterminism:
    def test_same_input_same_output(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r1 = cwm.transition(s, (a,))
        r2 = cwm.transition(s, (a,))
        assert r1.ts_ns == r2.ts_ns
        assert r1.account.equity == r2.account.equity

    def test_input_not_mutated(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        orig_ts = s.ts_ns
        orig_equity = s.account.equity
        cwm.transition(s, (_cross(Side.BUY, frac=0.1),))
        assert s.ts_ns == orig_ts
        assert s.account.equity == orig_equity

    def test_timestamp_advances(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        r = cwm.transition(s, (_noop(),))
        assert r.ts_ns > s.ts_ns

    def test_book_state_independent(self):
        cwm = MinimalCryptoLOBCWM()
        s1 = _state(bid=50000.0, ask=50001.0)
        s2 = _state(bid=49000.0, ask=49001.0)
        r1 = cwm.transition(s1, (_noop(),))
        r2 = cwm.transition(s2, (_noop(),))
        assert r1.book.mid != r2.book.mid


# ══════════════════════════════════════════════════════════════════════════════
# 13. EDGE CASES
# ══════════════════════════════════════════════════════════════════════════════

class TestEdgeCases:
    def test_noop_preserves_everything(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        r = cwm.transition(s, (_noop(),))
        assert r.account.equity == s.account.equity
        assert r.book.best_bid == s.book.best_bid
        assert len(r.open_orders) == len(s.open_orders)

    def test_zero_equity(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state(equity=0.0)
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        # Should not crash
        assert isinstance(r.account.equity, float)

    def test_empty_book_no_fill(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        # Remove all asks
        s = MarketWorldState(
            ts_ns=s.ts_ns, mode=s.mode, venue=s.venue,
            book=OrderBookState(ts_ns=s.book.ts_ns, symbol=s.book.symbol,
                                bids=s.book.bids, asks=()),
            account=s.account,
        )
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert r.account.equity == s.account.equity

    def test_very_small_qty(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.0001)
        r = cwm.transition(s, (a,))
        # Might be clipped to zero
        assert isinstance(r.account.equity, float)

    def test_consecutive_transitions(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        for _ in range(10):
            s = cwm.transition(s, (_noop(),))
        assert isinstance(s.account.equity, float)

    def test_consecutive_with_actions(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        for i in range(5):
            a = _place(Side.BUY, offset=i, frac=0.05, post_only=True)
            s = cwm.transition(s, (a,))
        assert len(s.open_orders) == 5


# ══════════════════════════════════════════════════════════════════════════════
# 14. TERMINAL
# ══════════════════════════════════════════════════════════════════════════════

class TestTerminal:
    def test_depth_zero(self):
        cwm = MinimalCryptoLOBCWM()
        assert cwm.terminal(_state(), 0)

    def test_no_intent(self):
        cwm = MinimalCryptoLOBCWM()
        assert cwm.terminal(_state(), 5)

    def test_with_intent_and_depth(self):
        cwm = MinimalCryptoLOBCWM()
        intent = ExecutionIntent(
            intent_id="t1", ts_ns=1, symbol="BTCUSDT",
            kind=IntentKind.ENTER_LONG, target_qty=0.01, max_notional=500.0,
            urgency=0.5, alpha_horizon_s=60.0, alpha_bps=2.0,
            max_slippage_bps=5.0, prefer_maker=True, reduce_only=False,
            ttl_s=300.0, reason="test",
        )
        s = _state(intent=intent)
        assert not cwm.terminal(s, 3)


# ══════════════════════════════════════════════════════════════════════════════
# 15. REWARD
# ══════════════════════════════════════════════════════════════════════════════

class TestReward:
    def _params(self):
        return FulfilmentPolicyParams(
            version="test", ucb_c=1.414, max_sims=64, max_depth=2,
            rollout_depth=2, root_temperature=0.5, min_root_entropy=0.25,
            quote_offsets_ticks=(0, 1), quote_size_fractions=(0.25,),
            passive_ttl_ms=200, aggressive_ttl_ms=50,
            maker_edge_min_bps=0.5, cross_spread_edge_min_bps=5.0,
            adverse_toxicity_cancel_threshold=0.5, queue_churn_cancel_threshold=0.5,
            mae_tail_cut_bps=50.0, mfe_giveback_cut_fraction=0.5,
            max_time_in_loss_s=300.0, failed_recovery_cut_count=3,
            recovery_velocity_min_bps_per_s=0.0,
            max_symbol_notional_fraction=0.20, max_single_order_notional_fraction=0.05,
            reduce_when_global_up_fraction=0.30, session_profit_lock_fraction=0.02,
            w_expected_pnl=1.0, w_fill_probability=0.5, w_adverse_selection=2.0,
            w_queue_priority=0.5, w_inventory_risk=1.5, w_tail_loss=5.0,
            w_fee_quality=0.5, w_time_decay=0.3, w_policy_entropy=0.5,
            robust_tail_weight=2.0, toxic_counterparty_weight=3.0,
            low_liquidity_weight=2.0, latency_stress_weight=1.0,
        )

    def test_noop_reward_zero(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        r = cwm.transition(s, (_noop(),))
        assert cwm.reward(s, _noop(), r, self._params()) == 0.0

    def test_cross_spread_penalty(self):
        cwm = MinimalCryptoLOBCWM()
        s = _state()
        a = _cross(Side.BUY, frac=0.1)
        r = cwm.transition(s, (a,))
        assert cwm.reward(s, a, r, self._params()) < 0

    def test_higher_w_tail_more_penalty(self):
        import dataclasses
        cwm = MinimalCryptoLOBCWM()
        path = _tp(mae=-40.0, failed_recovery_count=2)
        s = _state(trade_path=path)
        a = _noop()
        r = cwm.transition(s, (a,))
        p1 = self._params()
        p2_dict = dataclasses.asdict(p1)
        p2_dict["w_tail_loss"] = 10.0
        p2_dict["version"] = "t2"
        p2 = FulfilmentPolicyParams(**p2_dict)
        assert cwm.reward(s, a, r, p2) < cwm.reward(s, a, r, p1)