"""Concurrency tests for the _config_lock pattern used in P2.

The real WSHandler requires a full engine/store/ws stack to boot, which makes
a pure-unit concurrency test prohibitively heavy. Instead we test the *pattern*
applied in P2 — a single asyncio.Lock serializing any number of mixed
`add_role` and `reorg_decide` style coroutines — and assert:

  - Every operation completes (20 ops in our case).
  - `asyncio.Lock` never produces a RuntimeError ("lock already held") — which
    would indicate same-task reentry.
  - The log shows strictly interleaved entries (no two tasks recorded an
    "inside-lock" line between each other's enter/exit).
  - The whole batch completes well under the 10s budget.

Evidence: ws_handler.py:175 defines `self._config_lock = asyncio.Lock()`.
P2 wraps `_handle_reorg_decide`, `_handle_set_mode`, and the `company_profile`
swap under this same lock. The proof of no deadlock is static (D4 in the plan);
this test is a dynamic smoke that the cooperative-locking behavior holds.
"""
from __future__ import annotations

import asyncio
import time

import pytest


@pytest.mark.asyncio
async def test_add_role_and_reorg_decide_serialized():
    """20 mixed ops share one lock; no exceptions, no deadlock, finishes fast."""
    lock = asyncio.Lock()
    # Event log records enter/exit around the critical section so we can verify
    # the lock serialized the body. If two tasks ever interleaved between an
    # enter and its matching exit, the test fails.
    log: list[tuple[str, str]] = []  # (op, phase)

    async def guarded(op: str) -> None:
        async with lock:
            log.append((op, "enter"))
            # Yield to event loop so other tasks get a chance to observe
            # whether they see an "inside-lock" window (they should not).
            await asyncio.sleep(0)
            log.append((op, "exit"))

    started = time.monotonic()
    tasks = []
    for i in range(10):
        tasks.append(asyncio.create_task(guarded(f"add_role:{i}")))
        tasks.append(asyncio.create_task(guarded(f"reorg_decide:{i}")))

    results = await asyncio.gather(*tasks, return_exceptions=True)
    elapsed = time.monotonic() - started

    exceptions = [r for r in results if isinstance(r, BaseException)]
    assert exceptions == [], f"Unexpected exceptions: {exceptions}"

    # Every op must produce exactly one enter + one exit.
    assert len(log) == 40, f"Expected 40 log entries (20 ops × 2), got {len(log)}"

    # Verify lock-mutual-exclusion: iterating the log, each enter must be
    # immediately followed by the SAME op's exit (no interleave).
    i = 0
    while i < len(log):
        assert log[i][1] == "enter", f"Expected enter at index {i}, got {log[i]}"
        assert log[i + 1] == (log[i][0], "exit"), (
            f"Enter for {log[i][0]} was not immediately followed by its exit; "
            f"saw {log[i + 1]} — indicates lock was not held across the body."
        )
        i += 2

    # Counts must balance.
    add_role_count = sum(1 for (op, phase) in log if phase == "enter" and op.startswith("add_role"))
    reorg_count = sum(1 for (op, phase) in log if phase == "enter" and op.startswith("reorg_decide"))
    assert add_role_count == 10
    assert reorg_count == 10

    # 10s budget; a correct cooperative-lock implementation finishes in <1s.
    assert elapsed < 10.0, f"Test took {elapsed:.2f}s, exceeded 10s budget"


@pytest.mark.asyncio
async def test_lock_is_not_reentrant_from_same_task():
    """asyncio.Lock must NOT be re-acquirable from the same task (would deadlock).

    This is the invariant that the P2 plan relied on (D4 deadlock proof): if any
    code path under `_handle_reorg_decide` re-acquired `_config_lock` we'd
    deadlock. Here we verify the Lock primitive's behavior — the test passes
    only when a re-acquire attempt blocks forever (we force it to time out).
    """
    lock = asyncio.Lock()

    async def try_reentrant():
        async with lock:
            # Attempting to acquire again from the same task must block.
            try:
                await asyncio.wait_for(lock.acquire(), timeout=0.2)
            except asyncio.TimeoutError:
                return "blocked_as_expected"
            # Only reach here if stdlib ever became reentrant (it is not).
            lock.release()
            return "unexpected_reentry"

    outcome = await try_reentrant()
    assert outcome == "blocked_as_expected", (
        f"Expected asyncio.Lock to block on same-task re-acquire, got {outcome}"
    )