"""Concurrency / single-writer test for IntentService (REQ-007 NFR-2/NFR-3).

Many threads submit buy intents competing for the M-cap admission headroom
(asset-centric, BAT-030); exactly M must be admitted and no slot may be
double-used.
"""
from __future__ import annotations

import threading

from trex_core.adapters.persistence.in_memory_intent_store import InMemoryIntentStore
from trex_core.application.intents import BuyIntent, IntentService
from trex_core.domain.slot import SlotService, SlotState
from trex_core.domain.slot.in_memory_repository import InMemorySlotRepository

INST = "default"


def _wire(n_assets: int, max_active: int | None):
    repo = InMemorySlotRepository()
    svc = SlotService(repo, instance_key=INST)
    intents = IntentService(
        svc, repo, InMemoryIntentStore(),
        resolve_symbol=lambda pid: f"SYM-{pid}",
        instance_key=INST, max_active_slots=max_active,
    )
    repo.reconcile_universe(INST, {f"PF-{i}": "SYM" for i in range(n_assets)})
    return repo, svc, intents


def test_concurrent_buys_admit_at_most_m():
    repo, svc, intents = _wire(n_assets=20, max_active=5)

    results: list[str] = []
    results_lock = threading.Lock()

    def worker(i: int) -> None:
        d = intents.submit_buy(
            BuyIntent(intent_id=f"buy-{i}", qty=1, portfolio_id=f"PF-{i}")
        )
        with results_lock:
            results.append(d.status)

    threads = [threading.Thread(target=worker, args=(i,)) for i in range(20)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

    admitted = [s for s in results if s == "admitted"]
    pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
    # Capacity admission and transition share the same instance advisory lock.
    assert len(admitted) == len(pending)
    assert len(admitted) == 5
    assert len(results) == 20


def test_concurrent_buys_single_thread_serializer_respects_m():
    """Sequential submission (production: single intent consumer) admits exactly M."""
    repo, svc, intents = _wire(n_assets=20, max_active=5)
    results = [
        intents.submit_buy(BuyIntent(intent_id=f"buy-{i}", portfolio_id=f"PF-{i}")).status
        for i in range(20)
    ]
    assert results.count("admitted") == 5
    assert results.count("rejected") == 15
    pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
    assert len(pending) == 5


def test_duplicate_intent_id_admits_once_under_concurrency():
    repo, svc, intents = _wire(n_assets=5, max_active=5)

    statuses: list[str] = []
    lock = threading.Lock()

    def worker() -> None:
        d = intents.submit_buy(BuyIntent(intent_id="same-id", portfolio_id="PF-1"))
        with lock:
            statuses.append(d.status)

    threads = [threading.Thread(target=worker) for _ in range(10)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

    # same intent_id submitted 10x concurrently -> exactly ONE slot transitioned
    # (the core idempotency guarantee). Racing duplicates observe the winner's
    # decision, which may still be 'processing' before finalize; never 'rejected'.
    pending = [s for s in repo.list_slots(INST) if s.status is SlotState.PENDING_BUY]
    assert len(pending) == 1
    assert all(s in ("admitted", "processing") for s in statuses)


def test_concurrent_cached_cash_reservations_are_atomic_with_transition():
    repo = InMemorySlotRepository()
    svc = SlotService(repo, instance_key=INST)
    repo.reconcile_universe(INST, {"PF-0": "SYM", "PF-1": "SYM"})

    def cash_guard(intent: BuyIntent):
        reserved = sum(
            float(slot.qty or 0) * float(slot.limit_price or 0)
            for slot in repo.list_slots(INST, {"pending_buy"})
        )
        requested = float(intent.qty or 0) * float(intent.entry_price or 0)
        return None if reserved + requested <= 100 else "insufficient_snapshot_cash"

    intents = IntentService(
        svc,
        repo,
        InMemoryIntentStore(),
        resolve_symbol=lambda pid: f"SYM-{pid}",
        instance_key=INST,
        buy_guard_fn=cash_guard,
    )
    results = []
    result_lock = threading.Lock()

    def worker(index: int) -> None:
        decision = intents.submit_buy(
            BuyIntent(
                intent_id=f"cash-{index}",
                portfolio_id=f"PF-{index}",
                qty=1,
                entry_price=100,
            )
        )
        with result_lock:
            results.append(decision)

    threads = [threading.Thread(target=worker, args=(index,)) for index in range(2)]
    for thread in threads:
        thread.start()
    for thread in threads:
        thread.join()

    assert [decision.status for decision in results].count("admitted") == 1
    assert [decision.reason for decision in results].count(
        "insufficient_snapshot_cash"
    ) == 1
    assert len(repo.list_slots(INST, {"pending_buy"})) == 1