"""Synthetic workload replay. Quota points, not tokens or money. No future reset lookahead by policies."""
from pathlib import Path
from datetime import datetime,timedelta
from zoneinfo import ZoneInfo
import json,statistics
P=Path(__file__).resolve().parent
E=json.loads((P/'events_public.json').read_text())
Z=ZoneInfo('Asia/Tokyo'); START=datetime(2026,6,15,tzinfo=Z)
CAP=100.0; H=28.; DT=1/24

def simulate(events,policy,essential=10,demand=30,phase=7,timer='fixed',tickets=0):
    # Tickets are initially held, expire after day 26/27; no future gifts assumed.
    ticket_expiries=[26.+i for i in range(tickets)]
    r=CAP;next_regular=float(phase);e_done=d_done=e_missed=0.;backlog=0.;auto_waste=regular_waste=0.;used=0;expired=0;regulars=0;ticket_waste=0.;resets=0; constrained=0;mode_changes=0;prev=False
    boundaries=sorted(set([0.,H]+[i*DT for i in range(1,int(H/DT))]+[x for x in events if 0<x<H]+[float(i) for i in range(1,29)]))
    # Dynamic regular times must be processed exactly, not rounded to the grid.
    k=0;t=0.; event_set=set(events)
    while t<H-1e-9:
        expired+=sum(x<=t+1e-9 for x in ticket_expiries)
        ticket_expiries=[x for x in ticket_expiries if x>t+1e-9]
        if abs(t-next_regular)<1e-8:
            regular_waste+=r;regulars+=1;r=CAP;next_regular=t+7
        if t in event_set:
            auto_waste+=r;r=CAP;resets+=1
            if timer=='restart':next_regular=t+7
        while k<len(boundaries) and boundaries[k]<=t+1e-9:k+=1
        end=min(boundaries[k] if k<len(boundaries) else H,next_regular)
        dt=end-t
        # Every policy has the same emergency ticket rule: redeem only when essential work cannot run.
        need=essential*dt
        if r+1e-9<need and ticket_expiries:
            ticket_expiries.pop(0);ticket_waste+=r;r=CAP;used+=1
            if timer=='restart':next_regular=t+7
        e=min(r,need);r-=e;e_done+=e;e_missed+=need-e
        backlog+=(demand-essential)*dt
        if policy=='greedy':allowed=r
        elif policy=='paced':
            span=max(next_regular-t,dt)
            allowed=max(0,(r+e)/span*dt-need)
        elif policy in ('reserve','reserve_bank'):
            # Protect all essential work until known regular renewal, independent of surprise resets.
            reserve=essential*max(0,next_regular-end)
            if policy=='reserve_bank':
                reserve=max(0,reserve-CAP*sum(x>=next_regular for x in ticket_expiries))
            allowed=max(0,r-reserve)
        else:raise ValueError(policy)
        d=min(r,backlog,allowed);r-=d;backlog-=d;d_done+=d
        restricted=d+1e-7<(demand-essential)*dt
        if restricted:constrained+=dt
        if restricted!=prev:mode_changes+=1
        prev=restricted;t=end
        assert r>=-1e-7
    assert abs(CAP*(1+regulars+resets+used)-(e_done+d_done+r+auto_waste+regular_waste+ticket_waste))<1e-5
    assert abs(e_done+e_missed-essential*H)<1e-5
    assert abs(d_done+backlog-(demand-essential)*H)<1e-5
    return dict(tickets_expired=expired,ticket_unused= ticket_waste,essential_done=e_done,essential_missed=e_missed,optional_done=d_done,total_done=e_done+d_done,optional_backlog=backlog,auto_unused=auto_waste,regular_unused=regular_waste,terminal_balance=r,tickets_used=used,tickets_unspent=len(ticket_expiries),constrained_days=constrained,mode_changes=mode_changes)

def resets(provider,start):
    out=[]
    for e in E:
        if e['provider']!=provider or not e['count_main']:continue
        t=(datetime.fromisoformat(e['announcement_jst'])-start).total_seconds()/86400
        if 0<t<H:out.append(t)
    return sorted(out)

def summary(rs):
    return {k:{'mean':statistics.mean(r[k] for r in rs),'min':min(r[k] for r in rs),'max':max(r[k] for r in rs)} for k in rs[0]}|{'n':len(rs),'any_essential_miss':sum(r['essential_missed']>1e-6 for r in rs)}

def main():
    out=[]
    for provider in ['codex','claude']:
      for essential in [5,10]:
       for demand in [20,30,50]:
        for timer in ['fixed','restart']:
         for tickets in ([0,2] if provider=='codex' else [0]):
          for policy in ['paced','reserve','reserve_bank','greedy']:
            rs=[simulate(resets(provider,START+timedelta(weeks=w)),policy,essential,demand,phase,timer,tickets) for w in range(9) for phase in range(1,8)]
            out.append(dict(provider=provider,essential_per_day=essential,total_demand_per_day=demand,timer=timer,initial_tickets=tickets,policy=policy,**summary(rs)))
    shocks=[]
    for provider,tickets in [('codex',0),('codex',2),('claude',0)]:
      for timer in ['fixed','restart']:
       for pol in ['paced','reserve','reserve_bank','greedy']:
        shocks.append(dict(provider=provider,tickets=tickets,timer=timer,policy=pol,**simulate([],pol,10,30,7,timer,tickets)))
    (P/'simulation_results.json').write_text(json.dumps({'assumptions':{'horizon_days':28,'initial_balance':100,'essential_per_day':[5,10],'total_demand_per_day':[20,30,50],'regular_phase_days':list(range(1,8)),'windows':9,'step_hours':1,'future_ticket_grants':0,'ticket_expiry_days':[26,27],'claude_additional_credits':0,'lookahead':'policies only know current balance and regular reset date','warning':'synthetic, overlapping windows; not independent trials or measured productivity'},'replays':out,'no_surprise_stress':shocks},ensure_ascii=False,indent=2))
    print('scenario summaries',len(out),'paired runs',sum(r['n'] for r in out))
    for r in out:
      if r['essential_per_day']==10 and r['total_demand_per_day']==30:
       print(r['provider'],r['timer'],r['initial_tickets'],r['policy'],'optional',round(r['optional_done']['mean'],1),'essential_miss',round(r['essential_missed']['mean'],1),'miss_runs',r['any_essential_miss'],'tickets',round(r['tickets_used']['mean'],2))
if __name__=='__main__':main()