"""Server-owned stock facade. All writes use generated audited graph mutations."""
import asyncio,json,os,re,sys,time
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'
TRUSTED={'a':('ACTOR-A','TENANT-A','BUYER-A'),'b':('ACTOR-B','TENANT-A','BUYER-B'),'c':('ACTOR-C','TENANT-B','BUYER-A')}
class Denied(Exception):pass

def validate(token,r):
    if token not in TRUSTED:raise Denied('UNAUTHENTICATED')
    if any(k in r for k in ['tenant','buyer','actor','permissions','policy','userContext']):raise Denied('FORGED_SCOPE')
    if set(r)!={'requestKey','orderNumber','sku','quantity'}:raise Denied('INVALID_REQUEST')
    if type(r['quantity']) is not int or not 1<=r['quantity']<=10:raise Denied('INVALID_REQUEST')
    if not isinstance(r['requestKey'],str) or re.fullmatch('[A-Z0-9-]{1,64}',r['requestKey']) is None:raise Denied('INVALID_REQUEST')
    if any(not isinstance(r[k],str) or not 1<=len(r[k])<=64 for k in ['orderNumber','sku']):raise Denied('INVALID_REQUEST')

def conflict(error):
    t=str(error).lower()
    return not any(w in t for w in ['busy','locked','timeout']) and any(w in t for w in ['version','optimistic','conflict','stale','authoritative persisted state'])

async def barrier(root,order,inventory,r,token):
    if not os.environ.get('ORDER_BARRIER'):return
    folder=Path(os.environ['ORDER_BARRIER']);worker=os.environ['ORDER_WORKER']
    ready={'pid':os.getpid(),'session':token,'requestKey':r['requestKey'],'orderNumber':r['orderNumber'],'quantity':r['quantity'],'rootVersion':E.commerce_platform(root).version().eval(),'inventoryVersion':E.inventory(inventory).version().eval(),'available':E.inventory(inventory).available_quantity().eval(),'orderVersion':E.customer_order(order).version().eval()}
    temporary=folder/(worker+'.tmp');temporary.write_text(json.dumps(ready));temporary.replace(folder/(worker+'.ready'))
    deadline=time.monotonic()+45
    while not (folder/'release').exists():
        if time.monotonic()>deadline:raise RuntimeError('Barrier timeout')
        await asyncio.sleep(.01)

async def handle(context,token,r):
    reasons=[];attempts=0
    def result(code,receipt=None):return {'code':code,'receiptId':receipt,'attempts':attempts,'conflicts':len(reasons),'conflictReasons':reasons}
    try:
        validate(token,r);actor,tenant,buyer=TRUSTED[token]
        for attempt in range(3):
            attempts+=1
            roots=await (Q.commerce_platforms().with_tenant_key_is(tenant)
                .select_customer_order_list_with(Q.customer_orders().with_buyer_reference_is(buyer).with_order_number_is(r['orderNumber']).limit(2))
                .select_inventory_list_with(Q.inventory().with_sku_code_is(r['sku']).limit(2))
                .select_stock_reservation_list_with(Q.stock_reservations().with_buyer_reference_is(buyer).with_request_key_is(r['requestKey']).limit(2))
                .limit(2).comment('Load trusted tenant reservation aggregate').purpose('Bind Order inventory and receipt to server session').execute_for_list(context))
            if len(roots)!=1:raise RuntimeError('Invalid trusted root')
            root=roots[0];receipts=root.stock_reservation_list()
            if len(receipts)>1:raise RuntimeError('Duplicate persisted request key')
            if receipts:
                e=E.stock_reservation(receipts[0]);same=e.order_number().eval()==r['orderNumber'] and e.sku_code().eval()==r['sku'] and e.quantity().eval()==r['quantity']
                return result('REPLAY' if same else 'IDEMPOTENCY_CONFLICT',e.id().eval() if same else None)
            orders=root.customer_order_list();stocks=root.inventory_list()
            if len(orders)!=1 or len(stocks)!=1:raise Denied('NOT_FOUND')
            order,stock=orders[0],stocks[0];oe=E.customer_order(order);se=E.inventory(stock)
            if oe.order_status_id().eval()!=1001:raise Denied('ORDER_NOT_DRAFT')
            items=await (Q.order_items().filter_by_customer_order(oe.id().eval()).limit(2).comment('Validate complete bounded Order items').purpose('Reject mismatched reservation quantity or SKU').execute_for_list(context))
            if len(items)!=1 or E.order_item(items[0]).sku_code().eval()!=r['sku'] or E.order_item(items[0]).quantity().eval()!=r['quantity']:raise Denied('INVALID_ORDER_ITEMS')
            available,reserved=se.available_quantity().eval(),se.reserved_quantity().eval()
            if available<0 or reserved<0:raise RuntimeError('Invalid inventory')
            if available<r['quantity']:raise Denied('OUT_OF_STOCK')
            if attempt==0:await barrier(root,order,stock,r,token)
            root.update_reservation_sequence(E.commerce_platform(root).reservation_sequence().eval()+1);order.update_order_status(1002);stock.update_available_quantity(available-r['quantity']);stock.update_reserved_quantity(reserved+r['quantity'])
            receipt=Q.stock_reservations().comment('Create immutable scoped reservation receipt').purpose('Commit request idempotency with inventory').new_entity(context)
            receipt.update_commerce_platform(root);receipt.update_customer_order(order);receipt.update_inventory(stock);receipt.update_request_key(r['requestKey']);receipt.update_buyer_reference(buyer);receipt.update_quantity(r['quantity']);receipt.update_order_number(r['orderNumber']);receipt.update_sku_code(r['sku']);receipts.append(receipt)
            try:await root.audit_as(RESERVE).save(context)
            except Exception as error:
                if 'ORDER_PROVIDER_TEST_ABORT' in str(error):return {**result('PROVIDER_FAILED'),'reason':str(error)}
                if not conflict(error):raise
                reasons.append(str(error));continue
            saved=await (Q.stock_reservations().filter_by_commerce_platform(E.commerce_platform(root).id().eval()).with_buyer_reference_is(buyer).with_request_key_is(r['requestKey']).limit(2).comment('Read committed reservation receipt').purpose('Return durable idempotency identity').execute_for_list(context))
            assert len(saved)==1
            return result('RESERVED',E.stock_reservation(saved[0]).id().eval())
        return result('CONFLICT_LIMIT')
    except Denied as e:return result(str(e))

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)
class FaultGate:
    def __init__(self):
        self.active=False;self.mode=os.environ.get('ORDER_FAULT_MODE','');self.folder=Path(os.environ.get('ORDER_FAULT_BARRIER','.'));self.events=[]
    def event(self,kind,**details):
        if self.active:self.events.append({'event':kind,**details});print('ORDER_FAULT_EVENT '+json.dumps(self.events[-1]),flush=True)
    def publish(self,name,value):
        tmp=self.folder/(name+'.tmp');tmp.write_text(json.dumps(value));tmp.replace(self.folder/(name+'.json'))
    async def wait(self,name):
        deadline=time.monotonic()+45
        while not (self.folder/name).exists():
            if time.monotonic()>deadline:raise RuntimeError('Fault barrier timeout')
            await asyncio.sleep(.01)
    async def gate(self,point):
        if not self.active or (point=='after-inventory' and self.mode not in ['cancel','provider']) or (point=='before-commit' and self.mode not in ['commit','control']):return
        self.event('WAIT',point=point);self.publish('ready',{'pid':os.getpid(),'mode':self.mode,'point':point})
        if self.mode=='cancel':
            await self.wait('cancel');asyncio.current_task().cancel();await asyncio.sleep(0)
        else:await self.wait('release')

class ObservedTransaction(SqlTransactionTransportTx):
    def __init__(self,inner,gate):self.inner,self.g=inner,gate
    async def fetch_all_sql(self,query):return await self.inner.fetch_all_sql(query)
    async def execute_sql(self,query):
        result=await self.inner.execute_sql(query)
        if self.g.active and re.search(r'UPDATE\s+inventory_data',query.sql,re.I):await self.g.gate('after-inventory')
        return result
    async def commit_sql(self):
        await self.g.gate('before-commit');self.g.event('COMMIT_START')
        try:await self.inner.commit_sql();self.g.event('COMMIT_OK')
        except BaseException as e:self.g.event('COMMIT_ERROR',type=type(e).__name__,error=str(e));raise
    async def rollback_sql(self):
        self.g.event('ROLLBACK_START')
        try:await self.inner.rollback_sql();self.g.event('ROLLBACK_OK')
        except BaseException as e:self.g.event('ROLLBACK_ERROR',type=type(e).__name__,error=str(e));raise
class ObservedTransport(SqliteTransport):
    def __init__(self,path,gate):super().__init__(path);self.g=gate
    async def begin_sql(self):
        tx=await super().begin_sql();self.g.event('BEGIN_OK');return ObservedTransaction(tx,self.g)

async def fault_run(context,g):
    request={'requestKey':'REQ-FAULT','orderNumber':'ORD-STOCK-001','sku':'SKU-WIDGET','quantity':4}
    g.active=True;print('ORDER_FAULT_BEGIN',flush=True)
    async def operation():
        if g.mode=='pre-cancel':asyncio.current_task().cancel();await asyncio.sleep(0)
        return await handle(context,'a',request)
    task=asyncio.create_task(operation())
    try:
        first=await task
        outcome={'code':first['code'],'result':first}
    except asyncio.CancelledError as e:outcome={'code':'CANCELLED','type':type(e).__name__,'error':str(e)}
    except Exception as e:outcome={'code':'COMMIT_FAILED' if g.mode=='commit' else 'UNEXPECTED_ERROR','type':type(e).__name__,'error':str(e)}
    outcome.update(pid=os.getpid(),providerIdentity=id(context.require_resource('dataService')),contextIdentity=id(context),taskDone=task.done(),events=list(g.events))
    g.publish('failed',outcome);g.active=False;await g.wait('recovery');print('ORDER_FAULT_RECOVERY',flush=True);recovery=await handle(context,'a',request)
    print('ORDER_FAULT_RESULT '+json.dumps({'mode':g.mode,'first':outcome,'recovery':recovery,'sameProvider':outcome['providerIdentity']==id(context.require_resource('dataService')),'sameContext':outcome['contextIdentity']==id(context),'tasksJoined':task.done()}),flush=True)

async def main():
    phase=sys.argv[1];g=FaultGate();provider=create_sqlite_service(os.environ['ORDER_DATABASE']);provider.transport=ObservedTransport(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=='fault':await fault_run(context,g)
    elif phase!='bootstrap':raise RuntimeError('Unknown phase')
    print('ORDER_OK phase='+phase)
if __name__=='__main__':asyncio.run(main())
