#!/usr/bin/env python3
"""Deterministic policy lab, not a production breaker or library benchmark.
Python 3.11+, standard library only. Run: python3 experiment.py > results.json
Virtual time controls cooldown; asyncio barriers hold all admitted calls pending.
"""
import asyncio
import json
import platform
from dataclasses import dataclass


@dataclass
class Ticket:
    generation: int
    name: str
    done: bool = False


class Breaker:
    def __init__(self, bounded=True, fenced=True):
        self.bounded, self.fenced = bounded, fenced
        self.limit = 2
        self.now = 0
        self.state = 'OPEN'
        self.generation = 0
        self.reopen_at = 10
        self.used = self.successes = 0
        self.active = self.peak = self.rejected = 0
        self.stale = self.duplicate = 0
        self.trace = []
        self.lock = asyncio.Lock()

    def event(self, action, **details):
        self.trace.append(dict(action=action, state=self.state,
                               generation=self.generation, time=self.now, **details))

    def transition(self, state):
        self.state = state
        self.generation += 1
        self.used = self.successes = 0
        if state == 'OPEN':
            self.reopen_at = self.now + 10
        self.event('transition')

    async def admit(self, name):
        # State test and permit reservation share one critical section.
        async with self.lock:
            if self.state == 'OPEN' and self.now >= self.reopen_at:
                self.transition('HALF_OPEN')
            if self.state == 'OPEN' or (self.state == 'HALF_OPEN'
                                       and self.bounded and self.used >= self.limit):
                self.rejected += 1
                self.event('reject', name=name)
                return None
            assert self.state == 'HALF_OPEN', 'Lab submits only recovery calls'
            self.used += 1
            self.active += 1
            self.peak = max(self.peak, self.active)
            ticket = Ticket(self.generation, name)
            self.event('admit', name=name, active=self.active)
            return ticket

    async def finish(self, ticket, success=True, unused=False):
        async with self.lock:
            if ticket.done:
                self.duplicate += 1
                self.event('ignore-duplicate', name=ticket.name)
                return
            ticket.done = True
            self.active -= 1  # Physical completion is separate from generation accounting.
            if self.fenced and ticket.generation != self.generation:
                self.stale += 1
                self.event('ignore-stale', name=ticket.name,
                           ticketGeneration=ticket.generation)
                return
            if self.state != 'HALF_OPEN':
                self.event('completion-outside-half-open', name=ticket.name)
                return
            if unused:
                self.used -= 1  # Only a reservation never sent to a dependency is reusable.
                self.event('release-unused', name=ticket.name)
            elif not success:
                self.event('probe-failed', name=ticket.name)
                self.transition('OPEN')
            else:
                self.successes += 1
                self.event('probe-succeeded', name=ticket.name, successes=self.successes)
                if self.successes >= self.limit:
                    self.transition('CLOSED')

    async def expire_window(self):
        async with self.lock:
            assert self.state == 'HALF_OPEN'
            self.event('window-expired')
            self.transition('OPEN')  # Deliberately does not cancel physical operations.

    def result(self, case, **details):
        return dict(case=case, peakActive=self.peak, rejected=self.rejected,
                    finalState=self.state, staleIgnored=self.stale,
                    duplicateIgnored=self.duplicate, **details, trace=self.trace)


async def burst(breaker, n=8):
    ready = asyncio.Event()
    release = asyncio.Event()
    entered = 0
    admitted = []

    async def caller(i):
        nonlocal entered
        ticket = await breaker.admit(str(i))
        entered += 1
        if entered == n:
            ready.set()
        if ticket:
            admitted.append(ticket)
            await release.wait()
            await breaker.finish(ticket)

    tasks = [asyncio.create_task(caller(i)) for i in range(n)]
    await ready.wait()  # All permission decisions occur before any completion.
    pending = breaker.active
    release.set()
    await asyncio.gather(*tasks)
    return len(admitted), pending


async def main():
    cases = []
    for bounded in (False, True):
        b = Breaker(bounded=bounded)
        b.now = 10
        count, pending = await burst(b)
        assert (count, pending, b.rejected) == ((2, 2, 6) if bounded else (8, 8, 0))
        assert b.state == 'CLOSED'
        cases.append(b.result('bounded-burst' if bounded else 'state-only-burst',
                              attempted=8, admitted=count))

    b = Breaker(); b.now = 10
    a, z = await b.admit('a'), await b.admit('z')
    await b.finish(a)
    checkpoint = b.state
    assert checkpoint == 'HALF_OPEN'
    await b.finish(z, success=False)
    assert b.state == 'OPEN'
    cases.append(b.result('one-success-one-failure', afterFirstSuccess=checkpoint))

    for fenced in (False, True):
        b = Breaker(fenced=fenced); b.now = 10
        old = await b.admit('old-slow')
        failure = await b.admit('old-failure')
        await b.finish(failure, success=False)
        b.now = 20
        current = await b.admit('current-a')
        await b.finish(old)
        await b.finish(current)
        checkpoint = b.state
        assert checkpoint == ('HALF_OPEN' if fenced else 'CLOSED')
        if fenced:
            last = await b.admit('current-b')
            await b.finish(last)
        assert b.state == 'CLOSED'
        cases.append(b.result('late-success-fenced' if fenced else 'late-success-unfenced',
                              afterOldAndOneCurrent=checkpoint))

    b = Breaker(); b.now = 10
    old = [await b.admit('old-'+str(i)) for i in range(2)]
    b.now = 15
    await b.expire_window()
    b.now = 25
    current = [await b.admit('new-'+str(i)) for i in range(2)]
    assert b.active == 4 and b.peak == 4
    for t in old:
        await b.finish(t)
    assert b.state == 'HALF_OPEN' and b.successes == 0 and b.stale == 2
    for t in current:
        await b.finish(t)
    assert b.state == 'CLOSED' and b.active == 0
    cases.append(b.result('expired-window-old-work-pending', activeAcrossTwoGenerations=4))

    b = Breaker(); b.now = 10
    unused, active = await b.admit('unused'), await b.admit('active')
    assert await b.admit('before-release') is None
    await b.finish(unused, unused=True)
    replacement = await b.admit('replacement')
    assert replacement is not None
    await b.finish(active); await b.finish(replacement)
    assert b.state == 'CLOSED'
    cases.append(b.result('unused-reservation-returned', replacementAdmitted=True))

    b = Breaker(); b.now = 10
    a, z = await b.admit('a'), await b.admit('z')
    await b.finish(a); await b.finish(a)
    assert b.state == 'HALF_OPEN' and b.successes == 1 and b.active == 1
    await b.finish(z)
    assert b.state == 'CLOSED' and b.duplicate == 1
    cases.append(b.result('duplicate-completion-ignored', afterDuplicate='HALF_OPEN'))

    fleet = [Breaker() for _ in range(4)]
    tickets = []
    for b in fleet:
        b.now = 10
        tickets.append([await b.admit(str(i)) for i in range(2)])
    peak = sum(b.active for b in fleet)
    assert peak == 8
    for b, pair in zip(fleet, tickets):
        for t in pair:
            await b.finish(t)
    cases.append(dict(case='four-independent-breakers', instances=4,
                      permitsPerInstance=2, peakActive=peak, finalStates=[b.state for b in fleet]))

    print(json.dumps(dict(runtime=dict(python=platform.python_version()),
                          scope='Deterministic asyncio policy model, virtual time, no network or library benchmark',
                          policy=dict(permits=2, successesRequired=2, anyFailureReopens=True,
                                      cooldownVirtualUnits=10), cases=cases), indent=2))


if __name__ == '__main__':
    asyncio.run(main())
