"""Order acceptance through generated Q/E and the native SQLite provider."""
import asyncio
import json
import math
import os
import 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

SEED = "Seed the Order workflow fixture"
EDIT = "Edit draft Order quantity and totals atomically"


class InvalidQuantity(ValueError):
    pass


def report(case, value):
    print("ORDER_CASE " + json.dumps({"case": case, "value": value}))


async def load(context):
    rows = await (Q.customer_orders().with_order_number_is("ORD-2026-1001")
        .select_order_item_list_with(Q.order_items().order_by_sku_code_ascending().order_by_id_ascending().limit(101))
        .limit(2).comment("Load full draft order and complete bounded items")
        .purpose("Validate and edit one draft order").execute_for_list(context))
    assert len(rows) == 1
    order = rows[0]
    assert E.customer_order(order).order_status_id().eval() == 1001, "Only DRAFT orders can be edited"
    assert len(order.order_item_list()) <= 100, "Order item limit exceeded"
    return order


async def graph(context):
    orders = await (Q.customer_orders().order_by_order_number_ascending().order_by_id_ascending()
        .select_order_item_list_with(Q.order_items().order_by_sku_code_ascending().order_by_id_ascending().limit(101))
        .limit(10).comment("Read bounded orders with full item graphs")
        .purpose("Verify persisted Order workflow results").execute_for_list(context))
    return [{"orderNumber": E.customer_order(order).order_number().eval(),
        "totalMinor": E.customer_order(order).total_minor().eval(),
        "note": E.customer_order(order).order_note().eval(), "version": E.customer_order(order).version().eval(),
        "items": [{"sku": E.order_item(item).sku_code().eval(),
            "productName": E.order_item(item).product_name().eval(), "quantity": E.order_item(item).quantity().eval(),
            "unitPriceMinor": E.order_item(item).unit_price_minor().eval(),
            "lineTotalMinor": E.order_item(item).line_total_minor().eval(), "version": E.order_item(item).version().eval()}
            for item in order.order_item_list()]} for order in orders]


async def edit(context, quantity, rollback=False):
    if isinstance(quantity, bool) or not isinstance(quantity, (int, float)) or not math.isfinite(quantity) or quantity % 1 or quantity < 1 or quantity > 100:
        raise InvalidQuantity("Quantity must be an integer in [1, 100]")
    quantity = int(quantity)
    order = await load(context)
    assert E.customer_order(order).currency_code().eval() == "USD"
    items = order.order_item_list()
    matches = [item for item in items if E.order_item(item).sku_code().eval() == "SKU-NOTEBOOK"]
    assert len(matches) == 1
    changed, total = matches[0], 0
    for item in items:
        price, units = E.order_item(item).unit_price_minor().eval(), E.order_item(item).quantity().eval()
        assert isinstance(price, int) and 0 <= price <= 100000 and isinstance(units, int) and 1 <= units <= 100
        assert E.order_item(item).line_total_minor().eval() == price * units
        total += price * (quantity if item is changed else units)
    assert total <= 1000000000
    if rollback:
        winner = await (Q.order_items().with_id_is(E.order_item(changed).id().eval()).limit(2)
            .comment("Load independent item revision").purpose("Probe atomic rollback on stale child").execute_for_one(context))
        assert winner is not None
        winner.update_product_name("Notebook (concurrent winner)")
        await winner.audit_as("Advance Order item before stale graph probe").save(context)
    changed.update_quantity(quantity)
    changed.update_line_total_minor(quantity * E.order_item(changed).unit_price_minor().eval())
    order.update_total_minor(total)
    print("ORDER_GRAPH_ATTEMPT", flush=True)
    await order.audit_as(EDIT).save(context)


def missing(expression):
    try:
        expression()
    except Exception as error:
        return {"type": type(error).__name__, "message": str(error)}
    raise AssertionError("NotLoaded expression unexpectedly succeeded")


async def complete_read(context):
    orders = await (Q.customer_orders().order_by_order_number_ascending().order_by_id_ascending().limit(10)
        .comment("Read authoritative Order states").purpose("Verify transition persistence after restart").execute_for_list(context))
    deleted = await (Q.order_items().deleted_rows_only().with_sku_code_is("SKU-PEN").limit(10)
        .comment("Read retained deleted Order lines").purpose("Verify explicit soft deletion after restart").execute_for_list(context))
    return {"graph": await graph(context), "states": [{"orderNumber": E.customer_order(o).order_number().eval(),
        "statusId": E.customer_order(o).order_status_id().eval(), "version": E.customer_order(o).version().eval()} for o in orders],
        "deleted": [{"sku": E.order_item(i).sku_code().eval(), "version": E.order_item(i).version().eval()} for i in deleted]}

async def omit_preview(context):
    rows = await (Q.customer_orders().with_order_number_is("ORD-2026-1001")
        .select_order_item_list_with(Q.order_items().with_sku_code_is("SKU-NOTEBOOK").limit(2)).limit(2)
        .comment("Load complete scalars with a filtered item preview").purpose("Prove omitted items are not deletion commands").execute_for_list(context))
    assert len(rows) == 1 and len(rows[0].order_item_list()) == 1
    order = rows[0]; order.update_order_note("Edited through an item preview")
    await order.audit_as("Edit Order note without replacing its item collection").save(context)

async def remove_line(context, rollback):
    order = await load(context); items = order.order_item_list()
    targets = [i for i in items if E.order_item(i).sku_code().eval() == "SKU-PEN"]
    assert len(targets) == 1 and 1 < len(items) <= 100
    target, total = targets[0], 0
    for item in items:
        e = E.order_item(item); price, units = e.unit_price_minor().eval(), e.quantity().eval()
        assert isinstance(price, int) and 0 <= price <= 100000 and isinstance(units, int) and 1 <= units <= 100
        assert e.line_total_minor().eval() == price * units
        if item is not target: total += price * units
    assert total <= 1000000000
    if rollback:
        winner = await (Q.order_items().with_id_is(E.order_item(target).id().eval()).limit(2)
            .comment("Load independent deletion competitor").purpose("Test rollback when explicit deletion is stale").execute_for_one(context))
        assert winner is not None; winner.update_product_name("Pen (concurrent winner)")
        await winner.audit_as("Advance Order item before stale deletion probe").save(context)
    target.mark_for_deletion(); order.update_total_minor(total)
    print("ORDER_REMOVAL_ATTEMPT", flush=True)
    await order.audit_as("Remove Order line and recompute total atomically").save(context)

async def transition(context):
    target, next_state = os.environ["ORDER_TARGET"], int(os.environ["ORDER_NEXT_STATUS"])
    rows = await (Q.customer_orders().with_order_number_is(target).limit(2)
        .comment("Load full Order before state transition").purpose("Apply the Order lifecycle policy with original version").execute_for_list(context))
    assert len(rows) == 1; order = rows[0]; current = E.customer_order(order).order_status_id().eval()
    result = {"target": target, "from": current, "to": next_state, "observedVersion": E.customer_order(order).version().eval()}
    if (current, next_state) not in ((1001, 1002), (1001, 1003), (1002, 1003)):
        return dict(result, outcome="rejected", reason="Transition not allowed")
    if next_state == 1002: order.update_order_status_to_confirmed()
    else: order.update_order_status_to_cancelled()
    await order.audit_as("Apply an allowed Order status transition").save(context)
    return dict(result, outcome="committed", reason="")

def page_rows(orders, preview):
    result = []
    for order in orders:
        e = E.customer_order(order)
        row = dict(id=e.id().eval(), orderNumber=e.order_number().eval(), buyer=e.buyer_reference().eval(), totalMinor=e.total_minor().eval(), version=e.version().eval())
        if preview:
            row['items'] = [dict(id=E.order_item(i).id().eval(), sku=E.order_item(i).sku_code().eval(), lineTotalMinor=E.order_item(i).line_total_minor().eval(), version=E.order_item(i).version().eval()) for i in order.order_item_list()]
        result.append(row)
    return result


async def bounded_page(context):
    offset, limit, buyer = int(os.environ['ORDER_PAGE_OFFSET']), int(os.environ['ORDER_PAGE_LIMIT']), os.environ['ORDER_PAGE_BUYER']
    print('ORDER_PAGES_BEGIN', flush=True)
    if offset < 0 or limit < 1 or limit > 3:
        return dict(rejected=True, reason='Page bounds must be offset >= 0 and limit in [1, 3]')
    page = await (Q.customer_orders().with_buyer_reference_is(buyer).order_by_total_minor_ascending().order_by_id_ascending()
        .select_order_item_list_with(Q.order_items().order_by_sku_code_ascending().order_by_id_ascending().limit(1)).offset(offset).limit(limit).count()
        .comment('Read bounded Order pages').purpose('Compare filtered totals and per-order item previews').execute_for_list(context))
    assert page.total_count is not None
    return dict(offset=offset, limit=limit, buyer=buyer, rows=page_rows(page, True), total=page.total_count)


async def export_pages(context):
    mode = os.environ['ORDER_EXPORT_MODE']; complete = mode in ('asc', 'desc')
    assert mode in ('asc', 'desc', 'miss', 'composite', 'predicate')
    pages = []; fallback = 0; seek = 0; ended = False; print('ORDER_PAGES_BEGIN', flush=True)
    for index in range(10 if complete else 2):
        offset = (index + (1 if mode == 'miss' else 0)) * 3
        buyer = 'BUYER-CONTROL' if mode == 'predicate' and index == 1 else 'BUYER-EXPORT'
        query = Q.customer_orders().with_buyer_reference_is(buyer)
        if mode == 'composite': query = query.order_by_total_minor_ascending().order_by_id_ascending()
        elif mode == 'desc': query = query.order_by_id_descending()
        else: query = query.order_by_id_ascending()
        print('ORDER_EXPORT_PAGE ' + str(index), flush=True)
        page = await (query.offset(offset).limit(3).optimize_for_continuous_page_fetch_with('order-export-' + mode, 300).count()
            .comment('Export Order pages').purpose('Export complete bounded Order identities through one trusted context').execute_for_list(context))
        plan = context.continuous_page_plan(); assert plan and page.total_count is not None
        if plan == 'CURSOR_SEEK': seek += 1
        elif plan.startswith('OFFSET_FALLBACK:'): fallback += 1
        pages.append(dict(offset=offset, buyer=buyer, rows=page_rows(page, False), total=page.total_count, plan=plan))
        if complete and not page: ended = True; break
    assert not complete or ended, 'Export page budget exhausted'
    return dict(mode=mode, pages=pages, fallbackCount=fallback, seekCount=seek)


class ObservedIds:
    def __init__(self):
        from teaql.runtime.context import InMemoryIdSetStore
        self.delegate = InMemoryIdSetStore(); self.events = []; self.last_key = None
    def get(self, key):
        self.last_key = key; value = self.delegate.get(key); self.events.append(dict(op="get",key=key,hit=value is not None)); return value
    def put(self, value):
        self.delegate.put(value); self.events.append(dict(op="put",key=value.query_key,ids=list(value.ids)))
    def invalidate(self, key):
        assert key; self.delegate.invalidate(key); self.events.append(dict(op="invalidate",key=key))

async def retained_pages(context):
    import time
    mode=os.environ['ORDER_RETAINED_MODE']; store=ObservedIds(); context.set_id_set_store(store)
    offsets={'jumps':[6,0,3,9,0],'empty':[0,3],'overflow':[3,0],'isolation':[0,0,3],'expiry':[0,3],'invalidate':[0,3,6]}[mode]
    pages=[]; print('ORDER_INSIGHTS_BEGIN')
    for index,offset in enumerate(offsets):
        if mode=='expiry' and index==1:
            start=time.monotonic(); await asyncio.sleep(1.3); store.events.append(dict(op='wait',elapsedMs=int((time.monotonic()-start)*1000)))
        if mode=='invalidate' and index==2: store.invalidate(store.last_key)
        buyer='BUYER-MISSING' if mode=='empty' else 'BUYER-CONTROL' if mode=='isolation' and index==1 else 'BUYER-EXPORT'
        print('ORDER_RETAINED_PAGE',index)
        page=await (Q.customer_orders().with_buyer_reference_is(buyer).with_currency_code_is('USD').order_by_total_minor_ascending().order_by_id_ascending()
            .offset(offset).limit(3).optimize_pagination_with_id_set_config('order-retained-'+mode,1 if mode=='expiry' else 300,4 if mode=='overflow' else 20).count()
            .comment('Read retained Order IDs').purpose('Verify random jumps and retained-set lifecycle').execute_for_list(context))
        pages.append(dict(offset=offset,buyer=buyer,currency='USD',rows=page_rows(page,False),total=page.total_count,plan=context.id_set_plan(),observedCount=context.id_set_count()[0]))
    return dict(mode=mode,pages=pages,events=store.events)

async def order_summary(context):
    buyer=os.environ['ORDER_SUMMARY_BUYER'];currency=os.environ['ORDER_SUMMARY_CURRENCY'];minimum=int(os.environ['ORDER_SUMMARY_MINIMUM']);print('ORDER_INSIGHTS_BEGIN')
    groups=await (Q.customer_orders().with_buyer_reference_is(buyer).with_currency_code_is(currency).with_total_minor_greater_than_or_equal_to(minimum)
        .group_by_order_status().count_as('count').sum_total_minor_as('totalMinor').limit(4)
        .comment('Summarize filtered Order amounts by status').purpose('Compute same-currency Order summaries in the provider').execute_for_rows(context))
    summary=await (Q.customer_orders().with_buyer_reference_is(buyer).with_currency_code_is(currency).with_total_minor_greater_than_or_equal_to(minimum)
        .count_as('count').sum_total_minor_as('totalMinor').limit(1)
        .comment('Summarize the complete filtered Order set').purpose('Compare exact counts and money independent of page size').execute_for_rows(context))
    sets=[];rows=[];total=None
    for all_buckets in [True,False]:
        page=await (Q.customer_orders().with_buyer_reference_is(buyer).with_currency_code_is(currency).with_total_minor_greater_than_or_equal_to(minimum)
            .facet_by_order_status_as('statuses',Q.order_statuses_minimal().select_code().count_customer_orders_as('count').limit(4),all_buckets)
            .select_order_item_list_with(Q.order_items().order_by_sku_code_ascending().order_by_id_ascending().limit(1)).order_by_id_ascending().limit(3).count()
            .comment('Read Order status buckets and bounded item previews').purpose('Keep rows facets and counts on the same filtered set').execute_for_list(context))
        sets.append({r['code']:int(r['count']) for r in page.facet('statuses')})
        if all_buckets:rows=page_rows(page,True);total=page.total_count
    return dict(buyer=buyer,currency=currency,minimum=minimum,
        groups=[dict(statusId=int(r['order_status']),count=int(r['count']),totalMinor=r['totalMinor']) for r in groups],
        summary=[dict(count=int(r['count']),totalMinor=r['totalMinor']) for r in summary],
        allBuckets=sets[0],matchedBuckets=sets[1],rows=rows,total=total)


async def worker(context):
    from pathlib import Path
    import time
    name, target, note = (os.environ[key] for key in ("ORDER_WORKER", "ORDER_TARGET", "ORDER_NOTE"))
    rows = await (Q.customer_orders().with_order_number_is(target).limit(2)
        .comment("Load complete Order before write barrier").purpose("Retain original version for concurrent note update").execute_for_list(context))
    assert len(rows) == 1
    order = rows[0]
    result = dict(worker=name, target=target, note=note, pid=os.getpid(),
        observedVersion=E.customer_order(order).version().eval(), observedNote=E.customer_order(order).order_note().eval())
    barrier = Path(os.environ["ORDER_BARRIER"])
    temporary = barrier / (name + ".tmp")
    temporary.write_text(json.dumps(result)); temporary.rename(barrier / (name + ".ready"))
    deadline = time.monotonic() + 45
    while not (barrier / os.environ["ORDER_RELEASE"]).exists():
        assert time.monotonic() < deadline, "Worker barrier timeout"
        await asyncio.sleep(.01)
    order.update_order_note(note)
    outcome, reason = "committed", ""
    try:
        await order.audit_as("Revise Order note with optimistic version").save(context)
    except Exception as error:
        outcome, reason = "conflict", str(error)
    print("ORDER_WORKER " + json.dumps(dict(result, outcome=outcome, conflictReason=reason)))

async def main():
    if not __debug__:
        raise RuntimeError("Verification requires Python assertions")
    phase = sys.argv[1]
    context = UserContext.new().install(GENERATED_RUNTIME_MODULE)
    context.insert_resource("dataService", create_sqlite_service(os.environ["ORDER_DATABASE"]))
    if phase != "worker":
        await context.ensure_schema()
    if phase == "insights-retained":
        report(phase,await retained_pages(context))
    elif phase == "insights-summary":
        report(phase,await order_summary(context))
    elif phase == "pages-bounded":
        report(phase, await bounded_page(context))
    elif phase == "pages-export":
        report(phase, await export_pages(context))
    elif phase == "complete-read":
        report(phase, await complete_read(context))
    elif phase == "omission-probe":
        await omit_preview(context); report(phase, {"previewCount": 1})
    elif phase == "remove-line":
        await remove_line(context, False); report(phase, {"removed": "SKU-PEN"})
    elif phase == "remove-conflict":
        try: await remove_line(context, True)
        except Exception as error: report(phase, {"rejected": True, "reason": str(error)})
        else: raise AssertionError("Stale deletion accepted")
    elif phase == "transition":
        report(phase, await transition(context))
    elif phase == "guard-edit":
        try: await edit(context, 3)
        except AssertionError as error:
            assert str(error) == "Only DRAFT orders can be edited"
            report(phase, {"rejected": True, "reason": str(error)})
        else: raise AssertionError("Non-DRAFT edit accepted")
    elif phase == "worker":
        await worker(context)
    elif phase == "bootstrap":
        pass
    elif phase == "seed":
        with open(os.environ["ORDER_FIXTURE"]) as stream:
            fixture = json.load(stream)
        roots = await (Q.commerce_platforms_minimal().limit(2).comment("Read initialized commerce root")
            .purpose("Seed Order fixture").execute_for_list(context))
        assert len(roots) == 1
        for data in fixture["orders"]:
            order = Q.customer_orders().comment("Create fixture order").purpose("Seed Order workflow").new_entity(context)
            order.update_commerce_platform(roots[0])
            if data["order_status"] == "CONFIRMED": order.update_order_status_to_confirmed()
            elif data["order_status"] == "CANCELLED": order.update_order_status_to_cancelled()
            else:
                assert data["order_status"] == "DRAFT"
                order.update_order_status_to_draft()
            order.update_order_number(data["order_number"])
            order.update_buyer_reference(data["buyer_reference"])
            order.update_currency_code(data["currency_code"])
            order.update_total_minor(data["total_minor"])
            order.update_order_note(data["order_note"])
            saved = await order.audit_as(SEED).save(context)
            for line in data["items"]:
                item = Q.order_items().comment("Create fixture order item").purpose("Seed Order workflow").new_entity(context)
                item.update_customer_order(saved)
                item.update_sku_code(line["sku_code"])
                item.update_product_name(line["product_name"])
                item.update_quantity(line["quantity"])
                item.update_unit_price_minor(line["unit_price_minor"])
                item.update_line_total_minor(line["line_total_minor"])
                await item.audit_as(SEED).save(context)
    # scenario: draft-graph, restart-readback
    elif phase in ("p1-read", "draft-graph", "restart-readback"):
        report(phase, await graph(context))
    # scenario: note-value, note-null, note-empty
    elif phase in ("note-value", "note-null", "note-empty"):
        number = "ORD-2026-1002" if phase == "note-null" else "ORD-2026-1003" if phase == "note-empty" else "ORD-2026-1001"
        order = await (Q.customer_orders_minimal().select_order_note().with_order_number_is(number).limit(2)
            .comment("Select nullable order note").purpose("Verify loaded note and null-only default").execute_for_one(context))
        assert order is not None
        expression = E.customer_order(order).order_note()
        report(phase, {"value": expression.eval(), "fallback": expression.or_if_null("No note")})
    # scenario: note-not-loaded
    elif phase == "note-not-loaded":
        order = await (Q.customer_orders_minimal().select_order_number().with_order_number_is("ORD-2026-1001").limit(2)
            .comment("Omit order note from projection").purpose("Expose missing-field errors").execute_for_one(context))
        assert order is not None
        report(phase, {"eval": missing(lambda: E.customer_order(order).order_note().eval()),
            "fallback": missing(lambda: E.customer_order(order).order_note().or_if_null("No note"))})
    # scenario: invalid-quantity
    elif phase == "invalid-quantity":
        results = []
        for quantity in (0, -1, 1.5, 101):
            try:
                await edit(context, quantity)
            except InvalidQuantity as error:
                results.append({"quantity": quantity, "rejected": True, "reason": str(error)})
            else:
                raise AssertionError("Invalid quantity accepted")
        report(phase, results)
    # scenario: draft-edit
    elif phase == "draft-edit":
        await edit(context, 3)
        report(phase, await graph(context))
    elif phase == "rollback-probe":
        try:
            await edit(context, 3, True)
        except Exception as error:
            report(phase, {"rejected": True, "reason": str(error)})
        else:
            raise AssertionError("Stale child accepted")
    else:
        raise ValueError("Unknown phase: " + phase)
    print("ORDER_OK phase=" + phase)


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