"""CQRS blast-radius toy (stdlib only, deterministic).

Scenario: a shop with orders. At step 3 a payment bug appears: every
place_order call raises AND (like a leaked DB connection) never returns its
connection to the pool. We then fire 10 reads ("show my orders").

A) coupled      : reads and writes share one model + one connection pool.
B) cqrs_shared  : separate command/query models, but SAME pool (one process).
C) cqrs_split   : separate models, separate pools, read model fed by events.
"""
from collections import deque

class PoolExhausted(Exception): pass
class PaymentBug(Exception): pass

class Pool:
    def __init__(self, size): self.free = size
    def acquire(self):
        if self.free == 0: raise PoolExhausted("no connection")
        self.free -= 1
    def release(self): self.free += 1

def run(mode, pool_size=3, orders_before_bug=3, bug_writes=5, reads=10):
    write_pool = Pool(pool_size)
    read_pool = write_pool if mode in ("coupled", "cqrs_shared") else Pool(pool_size)
    store = {}                # write-side source of truth
    read_model = {}           # query-side projection (cqrs_split only)
    events = deque()
    bug = False
    w_ok = w_fail = 0

    def place_order(oid, user):
        nonlocal w_ok, w_fail
        write_pool.acquire()
        if bug:               # bug: raise before release -> leaked connection
            w_fail += 1
            raise PaymentBug(oid)
        store[oid] = user
        if mode == "cqrs_split": events.append(("OrderPlaced", oid, user))
        write_pool.release(); w_ok += 1

    def project():            # event handler: updates read model
        while events:
            _, oid, user = events.popleft(); read_model[oid] = user

    def my_orders(user):
        read_pool.acquire()
        try:
            src = read_model if mode == "cqrs_split" else store
            return sorted(o for o, u in src.items() if u == user)
        finally: read_pool.release()

    for i in range(orders_before_bug): place_order(f"o{i}", "alice")
    project()
    bug = True
    for i in range(bug_writes):
        try: place_order(f"x{i}", "alice")
        except PaymentBug: pass
        except PoolExhausted: w_fail += 1
    r_ok = 0; seen = None
    for _ in range(reads):
        try: seen = my_orders("alice"); r_ok += 1
        except PoolExhausted: pass
    return w_ok, w_fail, r_ok, reads, seen

for mode in ("coupled", "cqrs_shared", "cqrs_split"):
    w_ok, w_fail, r_ok, n, seen = run(mode)
    print(f"{mode:12s} writes ok={w_ok} failed={w_fail} | reads ok={r_ok}/{n} | last view={seen}")
