"""Option D cash/position write-back + estimate overlay tests (dcy-018, issue: cash stale).

Covers: LedgerWriter write-back to SnapshotStore on new/duplicate, skip when
*_after missing, best-effort isolation, and the slots handler's estimated-cash
overlay from pending outbox deltas (OQ-4).
"""
from __future__ import annotations

from datetime import datetime, timezone

from trex_core.adapters.ledger.in_memory import InMemoryLedger
from trex_core.application.ledger_outbox import (
    InMemoryLedgerOutbox,
    LedgerWriter,
    trade_cash_delta,
)
from trex_core.application.ledger_port import LedgerTrade
from trex_core.application.messaging import RpcRequest
from trex_core.application.messaging_handlers import make_slots_rpc_handler
from trex_core.application.portfolio import PortfolioItem, SnapshotStore
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository

UTC = timezone.utc


def _trade(execution_id="e-1", asset="PF-1", side="buy", qty=10, price=1000.0, fee=1.0):
    return LedgerTrade(asset_id=asset, order_id="O-1", execution_id=execution_id,
                       side=side, qty=qty, price=price, fee=fee,
                       executed_at=datetime(2026, 6, 4, tzinfo=UTC))


def _store_with(pid="PF-1", cash=1_000_000.0, qty=0.0):
    s = SnapshotStore()
    s.swap([PortfolioItem(portfolio_id=pid, symbol="005930",
                          cash_balance=cash, asset_quantity=qty)])
    return s


# --- write-back (REQ-019/030) ----------------------------------------------
def test_writeback_updates_snapshot_on_new():
    store = _store_with()
    outbox = InMemoryLedgerOutbox()
    ledger = InMemoryLedger(cash_after=300_000.0, quantity_after=10.0)
    writer = LedgerWriter(outbox, ledger, snapshot_store=store)
    outbox.enqueue(_trade())
    writer.run_once()
    a = store.get("PF-1").item
    assert a.cash_balance == 300_000.0 and a.asset_quantity == 10.0


def test_writeback_applies_on_duplicate_too():
    store = _store_with(cash=1_000_000.0)
    outbox = InMemoryLedgerOutbox()
    # execution already recorded once → second write is duplicate, *_after still authoritative
    ledger = InMemoryLedger(cash_after=300_000.0, quantity_after=10.0)
    ledger.record_trade(_trade(execution_id="dup"))   # pre-record → next is duplicate
    writer = LedgerWriter(outbox, ledger, snapshot_store=store)
    outbox.enqueue(_trade(execution_id="dup"))
    writer.run_once()
    assert store.get("PF-1").item.cash_balance == 300_000.0  # duplicate still wrote back


def test_writeback_skipped_when_after_missing():
    store = _store_with(cash=1_000_000.0)
    outbox = InMemoryLedgerOutbox()
    ledger = InMemoryLedger()  # no cash_after/quantity_after → None
    writer = LedgerWriter(outbox, ledger, snapshot_store=store)
    outbox.enqueue(_trade())
    writer.run_once()
    assert store.get("PF-1").item.cash_balance == 1_000_000.0  # unchanged


def test_writeback_best_effort_does_not_block_completion():
    class _BoomStore:
        def update_cash_position(self, *a, **k):
            raise RuntimeError("boom")
    outbox = InMemoryLedgerOutbox()
    ledger = InMemoryLedger(cash_after=1.0, quantity_after=1.0)
    writer = LedgerWriter(outbox, ledger, snapshot_store=_BoomStore())
    outbox.enqueue(_trade())
    stats = writer.run_once()
    assert stats.completed == 1  # ledger still completed despite write-back error


def test_no_writeback_without_store():
    outbox = InMemoryLedgerOutbox()
    ledger = InMemoryLedger(cash_after=1.0, quantity_after=1.0)
    writer = LedgerWriter(outbox, ledger)  # no snapshot_store
    outbox.enqueue(_trade())
    assert writer.run_once().completed == 1  # no crash


# --- estimate overlay (REQ-029 / OQ-4) — via make_slots_rpc_handler ----------
def test_pending_cash_delta_sums_by_asset():
    outbox = InMemoryLedgerOutbox()
    outbox.enqueue(_trade(execution_id="b", side="buy", qty=10, price=1000.0, fee=1.0))
    deltas = outbox.pending_cash_delta()
    assert deltas["PF-1"] == trade_cash_delta(_trade(side="buy", qty=10, price=1000.0, fee=1.0))
    assert deltas["PF-1"] == -(10 * 1000.0 + 1.0)  # buy: cash down


def test_apply_cash_estimate_overlays_pending_delta():
    """Cash-estimated overlay applied through slots handler (REQ-029 OQ-4)."""
    outbox = InMemoryLedgerOutbox()
    outbox.enqueue(_trade(execution_id="b", side="buy", qty=10, price=1000.0, fee=1.0))
    store = _store_with(pid="PF-1", cash=1_000_000.0, qty=0.0)
    repo = InMemorySlotRepository()
    repo.reconcile_universe("default", {"PF-1": "SYM"})
    handler = make_slots_rpc_handler(repo, snapshot_store=store, ledger_outbox=outbox)
    resp = handler(RpcRequest(payload={"filter": "all", "strategy_instance_id": "test-instance"}, correlation_id="test"))
    slots = resp.payload["slots"]
    pf1 = next(s for s in slots if s["portfolio_id"] == "PF-1")
    assert pf1["cash_estimated"] is True
    assert pf1["cash_balance"] == 1_000_000.0 - (10 * 1000.0 + 1.0)  # estimated cash


def test_estimate_clears_after_writeback():
    """Once the ledger write completes (no longer pending), the estimate is gone."""
    store = _store_with(cash=1_000_000.0)
    outbox = InMemoryLedgerOutbox()
    ledger = InMemoryLedger(cash_after=989_999.0, quantity_after=10.0)
    writer = LedgerWriter(outbox, ledger, snapshot_store=store)
    outbox.enqueue(_trade(side="buy", qty=10, price=1000.0, fee=1.0))
    assert outbox.pending_cash_delta()  # estimate present while pending
    writer.run_once()                    # completes → write-back authoritative
    assert outbox.pending_cash_delta() == {}  # no longer pending → no estimate
    assert store.get("PF-1").item.cash_balance == 989_999.0