"""Server-owned stock facade. All writes use generated audited graph mutations."""
import asyncio,json,os,re,sys,time,weakref,threading
from pathlib import Path
from Q import Q
from E import E
from runtime_module import GENERATED_RUNTIME_MODULE
from teaql.provider.sqlite import create_sqlite_service
from teaql.provider.sqlite.transport import SqliteTransport
from teaql.sql.executor import SqlTransactionTransportTx
from teaql.runtime import UserContext
SEED='Seed stock reservation fixture';RESERVE='Reserve Order inventory atomically'
async def seed(context):
    fixture=json.load(open(os.environ['ORDER_FIXTURE']));roots=await Q.commerce_platforms().limit(2).comment('Read initialized stock root').purpose(SEED).execute_for_list(context);assert len(roots)==1
    for n,t in enumerate(fixture['tenants']):
        root=roots[0] if n==0 else Q.commerce_platforms().comment('Create tenant').purpose(SEED).new_entity(context)
        root.update_name('Tenant '+t['key'][-1]);root.update_tenant_key(t['key']);root.update_reservation_sequence(0);await root.audit_as(SEED).save(context)
        for sku,qty in [(fixture['sku'],t['available']),(fixture['controlSku'],fixture['controlAvailable'])]:
            stock=Q.inventory().comment('Create SKU inventory').purpose(SEED).new_entity(context);stock.update_commerce_platform(root);stock.update_sku_code(sku);stock.update_available_quantity(qty);stock.update_reserved_quantity(0);stock.update_warehouse_note('Initial warehouse stock');await stock.audit_as(SEED).save(context)
        for buyer in fixture['buyers']:
            for d in fixture['orders']:
                o=Q.customer_orders().comment('Create stock Order').purpose(SEED).new_entity(context);o.update_commerce_platform(root);o.update_order_status_to_draft();o.update_order_number(d['number']);o.update_buyer_reference(buyer);o.update_currency_code('USD');o.update_total_minor(d['quantity']*fixture['unitPriceMinor']);o.update_order_note('Stock reservation fixture order');await o.audit_as(SEED).save(context)
                i=Q.order_items().comment('Create complete Order line').purpose(SEED).new_entity(context);i.update_customer_order(o);i.update_sku_code(fixture['sku']);i.update_product_name(fixture['sku']);i.update_quantity(d['quantity']);i.update_unit_price_minor(fixture['unitPriceMinor']);i.update_line_total_minor(d['quantity']*fixture['unitPriceMinor']);await i.audit_as(SEED).save(context)

REASON='Stress Order and item atomically'
FOLDER=Path(os.environ.get('ORDER_STRESS_FOLDER','.'))
def publish(name,value):
    p=FOLDER/(name+'.tmp');p.write_text(json.dumps(value));p.replace(FOLDER/(name+'.json'))
async def wait(name):
    end=time.monotonic()+90
    while not (FOLDER/name).exists():
        if time.monotonic()>end:raise RuntimeError('Stress protocol timeout '+name)
        await asyncio.sleep(.002)
class Gate:
    mode='normal';calibrate=False;transactions=0;tasks=0;started=0;finished=0
    async def checkpoint(self):
        if self.mode=='cancel':
            if self.calibrate:publish('held',self.metrics());await wait('held-release')
            asyncio.current_task().cancel();await asyncio.sleep(0)
    def metrics(self):
        return {'activeTransactions':self.transactions,'activeTasks':self.tasks,'startedTasks':self.started,'finishedTasks':self.finished,'openConnections':sum(getattr(c,'_connection',None) is not None for c in self.transport.connections),'fd':len(os.listdir('/dev/fd')),'threads':threading.active_count()}
class Tx(SqlTransactionTransportTx):
    def __init__(self,inner,g):self.inner,self.g,self.done=inner,g,False
    async def fetch_all_sql(self,q):return await self.inner.fetch_all_sql(q)
    async def execute_sql(self,q):
        result=await self.inner.execute_sql(q)
        if re.search(r'UPDATE\s+"?customer_order_data',q.sql,re.I):await self.g.checkpoint()
        return result
    def finish(self):
        if not self.done:self.done=True;self.g.transactions-=1
    async def commit_sql(self):
        try:await self.inner.commit_sql()
        finally:self.finish()
    async def rollback_sql(self):
        try:await self.inner.rollback_sql()
        finally:self.finish()
class Transport(SqliteTransport):
    def __init__(self,path,g):super().__init__(path);self.g=g;self.connections=weakref.WeakSet();g.transport=self
    async def _prepare(self,db):
        self.connections.add(db);return await super()._prepare(db)
    async def begin_sql(self):
        tx=await super().begin_sql();self.g.transactions+=1;return Tx(tx,self.g)
async def edit(context,g,r):
    roots=await Q.commerce_platforms().with_tenant_key_is('TENANT-A').limit(2).comment('Resolve trusted stress tenant').purpose(REASON).execute_for_list(context);assert len(roots)==1
    orders=await Q.customer_orders().filter_by_commerce_platform(E.commerce_platform(roots[0]).id().eval()).with_buyer_reference_is(r['buyer']).with_order_number_is(r['orderNumber']).select_order_item_list_with(Q.order_items().limit(2)).limit(2).comment('Load complete bounded Order and item').purpose(REASON).execute_for_list(context);assert len(orders)==1
    o=orders[0];items=o.order_item_list();assert len(items)==1;i=items[0]
    result={'originalOrderVersion':E.customer_order(o).version().eval(),'originalItemVersion':E.order_item(i).version().eval()}
    if r.get('cohort'):publish('preloaded',result);await wait('cohort-release')
    o.update_order_note(r['token']);i.update_product_name(r['token'])
    try:await o.audit_as(REASON).save(context);result['outcome']='COMMITTED'
    except asyncio.CancelledError as e:result.update(outcome='CANCELLED',error=type(e).__name__)
    except Exception as e:
        text=str(e);lower=text.lower();code='PROVIDER_FAILED' if 'ORDER_STRESS_PROVIDER_ABORT' in text else 'CONFLICT' if not any(w in lower for w in ['busy','locked','timeout']) and any(w in lower for w in ['version','optimistic','conflict','stale','authoritative persisted state']) else 'ERROR';result.update(outcome=code,error=text,type=type(e).__name__)
    return result
async def worker(context,g):
    publish('ready',{'pid':os.getpid(),'providerIdentity':id(context.require_resource('dataService'))})
    n=0
    while True:
        await wait(str(n)+'.command.json');r=json.loads((FOLDER/(str(n)+'.command.json')).read_text());action=r['action']
        if action=='edit':
            g.mode=r['mode'];g.calibrate=r.get('calibrate',False);g.tasks+=1;g.started+=1
            task=asyncio.create_task(edit(context,g,r))
            try:result=await task
            finally:g.tasks-=1;g.finished+=1
            assert task.done()
        else:result={}
        # Let aiosqlite's closing thread finish, without retaining completed requests.
        await asyncio.sleep(.001)
        result.update(metrics=g.metrics(),pid=os.getpid(),closed=action=='close')
        publish(str(n)+'.result',result);n+=1
        if action=='close':break
async def main():
    phase=sys.argv[1];g=Gate();provider=create_sqlite_service(os.environ['ORDER_DATABASE']);provider.transport=Transport(os.environ['ORDER_DATABASE'],g)
    context=UserContext.new().install(GENERATED_RUNTIME_MODULE);context.insert_resource('dataService',provider)
    if phase in ['bootstrap','seed']:await context.ensure_schema()
    if phase=='seed':await seed(context)
    elif phase=='stress':await worker(context,g)
    elif phase!='bootstrap':raise RuntimeError('Unknown phase')
    print('ORDER_OK phase='+phase)
if __name__=='__main__':asyncio.run(main())
