"""Application-owned authorization facade; never expose raw Q as a public API."""
import asyncio,json,os,sys
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.runtime import UserContext
from teaql.runtime.context import InMemoryIdSetStore

SEED='Seed isolated tenant Order fixture'
NOTE='Edit own tenant and buyer Order note'
ITEM='Edit own tenant and buyer Order item label'
TRUSTED={'a':('ACTOR-A','TENANT-A','BUYER-A'), 'b':('ACTOR-B','TENANT-A','BUYER-B'),
         'c':('ACTOR-C','TENANT-B','BUYER-A'), 'd':('ACTOR-D','TENANT-B','BUYER-B'),
         'readonly':('ACTOR-READ','TENANT-A','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')
    op=r.get('op');allowed={'list','detail','items','summary','retained','edit-note','edit-item'}
    if op not in allowed or set(r)-{'op','orderId','orderNumber','itemId','limit','patch'}: raise Denied('INVALID_REQUEST')
    limit=r.get('limit',2)
    if type(limit) is not int or not 1<=limit<=2: raise Denied('INVALID_BOUNDS')
    for k in ['orderId','itemId']:
        if k in r and (type(r[k]) is not int or r[k]<=0): raise Denied('INVALID_REQUEST')
    if op in ['detail','items','edit-note','edit-item'] and not ('orderId' in r or isinstance(r.get('orderNumber'),str)): raise Denied('INVALID_REQUEST')
    if op in ['items','edit-item'] and 'itemId' not in r: raise Denied('INVALID_REQUEST')
    if op.startswith('edit-'):
        if token=='readonly': raise Denied('FORBIDDEN_OPERATION')
        field='orderNote' if op=='edit-note' else 'productName';patch=r.get('patch')
        if not isinstance(patch,dict) or set(patch)!={field} or not isinstance(patch[field],str) or not 1<=len(patch[field])<=80: raise Denied('FORBIDDEN_FIELD')
    elif 'patch' in r: raise Denied('FORBIDDEN_FIELD')
    return op,limit

def row(o,include_items=True):
    result={'id':E.customer_order(o).id().eval(),'buyer':E.customer_order(o).buyer_reference().eval(),
            'orderNumber':E.customer_order(o).order_number().eval(),'note':E.customer_order(o).order_note().eval(),
            'totalMinor':E.customer_order(o).total_minor().eval(),'version':E.customer_order(o).version().eval()}
    if include_items:result['items']=[{'id':E.order_item(i).id().eval(),'sku':E.order_item(i).sku_code().eval(),'productName':E.order_item(i).product_name().eval(),'version':E.order_item(i).version().eval()} for i in o.order_item_list()]
    return result

async def handle(context,token,r):
    try:
        op,limit=validate(token,r);actor,tenant,buyer=TRUSTED[token]
        roots=await (Q.commerce_platforms().with_tenant_key_is(tenant).limit(2)
            .comment('Resolve tenant from trusted server session').purpose('Bind the authorized Order scope').execute_for_list(context))
        if len(roots)!=1: raise Denied('INVALID_TRUSTED_SCOPE')
        root=roots[0]
        def scoped(): return Q.customer_orders().filter_by_commerce_platform(E.commerce_platform(root).id().eval()).with_buyer_reference_is(buyer)
        if op=='summary':
            values=await (scoped().count_as('count').sum_total_minor_as('amount').limit(1)
                .comment('Summarize only authorized Orders').purpose('Enforce tenant and buyer scope on aggregates').execute_for_rows(context))
            return {'code':'OK','actor':actor,'tenant':tenant,'buyer':buyer,'count':values[0]['count'],'amount':values[0]['amount']}
        q=scoped().order_by_id_ascending()
        if op!='retained':q=q.select_order_item_list_with(Q.order_items().order_by_id_ascending().limit(3))
        if 'orderId' in r:q=q.with_id_is(r['orderId'])
        if 'orderNumber' in r:q=q.with_order_number_is(r['orderNumber'])
        if op=='retained':q=q.optimize_pagination_with_id_set_config('order-isolation-shared',300,20)
        fetched=await (q.limit(limit).comment('Load authorized Orders and bounded owned items')
            .purpose('Apply trusted tenant and buyer predicates before provider access').execute_for_page(context,0,limit))
        page=fetched.data
        plan=context.id_set_plan() if op=='retained' else None
        if op in ['list','retained']:
            result={'code':'OK','actor':actor,'tenant':tenant,'buyer':buyer,'rows':[row(o,op!='retained') for o in page],'total':fetched.total_count}
            if plan is not None:result['plan']=plan
            return result
        if len(page)!=1:raise Denied('NOT_FOUND')
        order=page[0];items=order.order_item_list()
        if len(items)>2:raise Denied('ITEM_LIMIT')
        item=next((i for i in items if E.order_item(i).id().eval()==r.get('itemId')),None)
        if op in ['items','edit-item'] and item is None:raise Denied('NOT_FOUND')
        if op=='edit-note':
            order=await (scoped().with_id_is(E.customer_order(order).id().eval()).limit(2)
                .comment('Reload authorized complete Order scalars').purpose('Save one authorized note without touching item graphs').execute_for_one(context))
            if order is None:raise Denied('NOT_FOUND')
            order.update_order_note(r['patch']['orderNote']);await order.audit_as(NOTE).save(context);return {'code':'OK','changed':True}
        if op=='edit-item':
            item.update_product_name(r['patch']['productName']);await item.audit_as(ITEM).save(context);return {'code':'OK','changed':True}
        result=row(order)
        if op=='items':result['items']=[i for i in result['items'] if i['id']==r['itemId']]
        return {'code':'OK','actor':actor,'tenant':tenant,'buyer':buyer,'rows':[result],'total':fetched.total_count}
    except Denied as e:return {'code':str(e)}

async def seed(context):
    roots=await (Q.commerce_platforms().limit(2).comment('Read initialized tenant root').purpose('Seed isolated Order fixture').execute_for_list(context))
    assert len(roots)==1
    for n,tenant in enumerate(['TENANT-A','TENANT-B']):
        root=roots[0] if n==0 else Q.commerce_platforms().comment('Create tenant root').purpose('Seed isolated Order fixture').new_entity(context)
        root.update_name('Tenant '+tenant[-1]);root.update_tenant_key(tenant);saved=await root.audit_as(SEED).save(context)
        for buyer in ['BUYER-A','BUYER-B']:
            for number in ['ORD-SHARED-001','ORD-SHARED-002']:
                o=Q.customer_orders().comment('Create tenant-owned Order').purpose('Seed isolated Order fixture').new_entity(context)
                o.update_commerce_platform(saved);o.update_order_status_to_draft();o.update_order_number(number);o.update_buyer_reference(buyer)
                o.update_currency_code('USD');o.update_total_minor(3850);o.update_order_note('Original '+tenant+' '+buyer)
                persisted=await o.audit_as(SEED).save(context)
                for sku,quantity,price,total in [('SKU-NOTEBOOK',2,1250,2500),('SKU-PEN',3,450,1350)]:
                    i=Q.order_items().comment('Create owned Order line').purpose('Seed isolated Order fixture').new_entity(context)
                    i.update_customer_order(persisted);i.update_sku_code(sku);i.update_product_name(sku);i.update_quantity(quantity);i.update_unit_price_minor(price);i.update_line_total_minor(total)
                    await i.audit_as(SEED).save(context)

async def main():
    context=UserContext.new().install(GENERATED_RUNTIME_MODULE);context.set_id_set_store(InMemoryIdSetStore());context.insert_resource('dataService',create_sqlite_service(os.environ['ORDER_DATABASE']))
    phase=sys.argv[1]
    if phase in ['bootstrap','seed']:await context.ensure_schema()
    if phase=='seed':await seed(context)
    elif phase=='request':
        request=json.load(open(os.environ['ORDER_REQUEST']));print('ORDER_ISOLATION_BEGIN',flush=True)
        result=await handle(context,os.environ.get('ORDER_SESSION',''),request);print('ORDER_ISOLATION_RESULT '+json.dumps(result))
    elif phase=='cache':
        print('ORDER_ISOLATION_BEGIN',flush=True);pages=[]
        for token in ['a','b','c','a']:pages.append(await handle(context,token,{'op':'retained','limit':1}))
        print('ORDER_ISOLATION_RESULT '+json.dumps({'pages':pages}))
    elif phase!='bootstrap':raise RuntimeError('Unknown phase')
    print('ORDER_OK phase='+phase)
if __name__=='__main__':asyncio.run(main())
