package com.example.orderworkflowservice;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.example.orderworkflowservice.customerorder.CustomerOrder;
import com.example.orderworkflowservice.orderitem.OrderItem;
import io.teaql.core.UserContext;
import java.nio.file.Path;
import java.util.*;
import java.util.function.Supplier;

/** Application-owned Order acceptance; generated library files are unchanged. */
public final class OrderCheck {
    private static final ObjectMapper JSON = new ObjectMapper();
    private static final String SEED = "Seed the Order workflow fixture";
    private static final String EDIT = "Edit draft Order quantity and totals atomically";
    private static Map<String,Object> object(Object... pairs) {
        var result = new LinkedHashMap<String,Object>();
        for (int i=0;i<pairs.length;i+=2) result.put((String)pairs[i],pairs[i+1]);
        return result;
    }
    private static void require(boolean value, String message) {
        if (!value) throw new IllegalStateException(message);
    }
    private static void report(String name, Object value) throws Exception {
        System.out.println("ORDER_CASE " + JSON.writeValueAsString(object("case",name,"value",value)));
    }
    private static CustomerOrder load(UserContext context) {
        var rows = Q.customerOrders().withOrderNumberIs("ORD-2026-1001").selectOrderStatus()
            .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(101))
            .limit(2).comment("Load full draft order and complete bounded items")
            .purpose("Validate and edit one draft order").executeForList(context);
        require(rows.size()==1,"Expected one draft order");
        require(status(rows.get(0))==1001,"Only DRAFT orders can be edited");
        require(rows.get(0).getOrderItemList().size()<=100,"Order item limit exceeded");
        return rows.get(0);
    }
    private static List<Object> graph(UserContext context) {
        var rows = Q.customerOrders().orderByOrderNumberAscending().orderByIdAscending()
            .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(101))
            .limit(10).comment("Read bounded orders with full item graphs")
            .purpose("Verify persisted Order workflow results").executeForList(context);
        var result = new ArrayList<Object>();
        for (var order : rows) {
            var children = new ArrayList<Object>();
            for (var item : order.getOrderItemList()) {
                var e=E.orderItem(item);
                children.add(object("sku",e.getSkuCode().eval(),"productName",e.getProductName().eval(),
                    "quantity",e.getQuantity().eval(),"unitPriceMinor",e.getUnitPriceMinor().eval(),
                    "lineTotalMinor",e.getLineTotalMinor().eval(),"version",e.getVersion().eval()));
            }
            var e=E.customerOrder(order);
            result.add(object("orderNumber",e.getOrderNumber().eval(),"totalMinor",e.getTotalMinor().eval(),
                "note",e.getOrderNote().eval(),"version",e.getVersion().eval(),"items",children));
        }
        return result;
    }
    private static void edit(UserContext context, double quantity, boolean rollback) {
        if (!Double.isFinite(quantity) || quantity!=Math.rint(quantity) || quantity<1 || quantity>100)
            throw new IllegalArgumentException("Quantity must be an integer in [1, 100]");
        var order=load(context);
        require("USD".equals(E.customerOrder(order).getCurrencyCode().eval()),"Expected USD");
        OrderItem changed=null; int total=0;
        for (var item : order.getOrderItemList()) {
            var e=E.orderItem(item); int price=e.getUnitPriceMinor().eval();
            int units=e.getQuantity().eval();
            require(price>=0 && price<=100000 && units>=1 && units<=100,"Invalid stored money or quantity");
            require(e.getLineTotalMinor().eval()==Math.multiplyExact(units,price),"Invalid stored line total");
            if ("SKU-NOTEBOOK".equals(e.getSkuCode().eval())) {
                require(changed==null,"Duplicate target SKU"); changed=item; units=(int)quantity;
            }
            total=Math.addExact(total,Math.multiplyExact(units,price));
        }
        require(changed!=null && total<=1000000000,"Invalid edit total");
        if (rollback) {
            var winner=Q.orderItems().withIdIs(E.orderItem(changed).getId().eval()).limit(2)
                .comment("Load independent item revision").purpose("Probe atomic rollback on stale child").executeForOne(context);
            Objects.requireNonNull(winner).updateProductName("Notebook (concurrent winner)");
            winner.auditAs("Advance Order item before stale graph probe").save(context);
        }
        changed.updateQuantity((int)quantity);
        changed.updateLineTotalMinor(Math.multiplyExact((int)quantity,E.orderItem(changed).getUnitPriceMinor().eval()));
        order.updateTotalMinor(total);
        System.out.println("ORDER_GRAPH_ATTEMPT");
        order.auditAs(EDIT).save(context);
    }
    private static Object missing(Supplier<?> expression) {
        try { expression.get(); }
        catch (RuntimeException error) { return object("type",error.getClass().getName(),"message",error.toString()); }
        throw new IllegalStateException("NotLoaded expression unexpectedly succeeded");
    }
    // Two independent processes retain the fully loaded original version until release.
    private static long status(CustomerOrder order) {
        return E.orderStatus(Objects.requireNonNull(E.customerOrder(order).getOrderStatus().eval())).getId().eval();
    }
    private static Object completeRead(UserContext context) {
        var orders=Q.customerOrders().selectOrderStatus().orderByOrderNumberAscending().orderByIdAscending().limit(10)
            .comment("Read authoritative Order states").purpose("Verify transition persistence after restart").executeForList(context);
        var states=new ArrayList<Object>();for(var order:orders)states.add(object("orderNumber",E.customerOrder(order).getOrderNumber().eval(),"statusId",status(order),"version",E.customerOrder(order).getVersion().eval()));
        var items=Q.orderItems().deletedRowsOnly().withSkuCodeIs("SKU-PEN").limit(10)
            .comment("Read retained deleted Order lines").purpose("Verify explicit soft deletion after restart").executeForList(context);
        var deleted=new ArrayList<Object>();for(var item:items)deleted.add(object("sku",E.orderItem(item).getSkuCode().eval(),"version",E.orderItem(item).getVersion().eval()));
        return object("graph",graph(context),"states",states,"deleted",deleted);
    }
    private static void omitPreview(UserContext context) {
        var rows=Q.customerOrders().withOrderNumberIs("ORD-2026-1001")
            .selectOrderItemListWith(Q.orderItems().withSkuCodeIs("SKU-NOTEBOOK").limit(2)).limit(2)
            .comment("Load complete scalars with a filtered item preview").purpose("Prove omitted items are not deletion commands").executeForList(context);
        require(rows.size()==1 && rows.get(0).getOrderItemList().size()==1,"Expected one preview line");
        var order=rows.get(0);order.updateOrderNote("Edited through an item preview");order.auditAs("Edit Order note without replacing its item collection").save(context);
    }
    private static void removeLine(UserContext context, boolean rollback) {
        var order=load(context);var items=order.getOrderItemList();require(items.size()>1 && items.size()<=100,"Invalid full item count");
        var targets=items.stream().filter(i->"SKU-PEN".equals(E.orderItem(i).getSkuCode().eval())).toList();require(targets.size()==1,"Expected one removal target");
        var target=targets.get(0);int total=0;
        for(var item:items) {var e=E.orderItem(item);int price=e.getUnitPriceMinor().eval(),units=e.getQuantity().eval();
            require(price>=0 && price<=100000 && units>=1 && units<=100 && e.getLineTotalMinor().eval()==Math.multiplyExact(price,units),"Invalid persisted item amount");
            if(item!=target)total=Math.addExact(total,Math.multiplyExact(price,units));}
        require(total<=1000000000,"Total overflow");
        if(rollback) {
            var winner=Q.orderItems().withIdIs(E.orderItem(target).getId().eval()).limit(2)
                .comment("Load independent deletion competitor").purpose("Test rollback when explicit deletion is stale").executeForOne(context);
            Objects.requireNonNull(winner).updateProductName("Pen (concurrent winner)");winner.auditAs("Advance Order item before stale deletion probe").save(context);
        }
        // A graph may schedule deletes first. Bind both explicit saves to the same native provider transaction.
        var scalarRows=Q.customerOrders().withOrderNumberIs("ORD-2026-1001").limit(2)
            .comment("Reload complete order scalars without child mutations").purpose("Write total before explicit deletion in one provider transaction").executeForList(context);
        require(scalarRows.size()==1,"Expected one scalar order");var scalarOrder=scalarRows.get(0);
        target.markForDeletion();scalarOrder.updateTotalMinor(total);System.out.println("ORDER_REMOVAL_ATTEMPT");
        var executor=((io.teaql.runtime.DefaultUserContext)context).getRuntime().getRegistry().resolveMutationExecutor("default");
        require(executor instanceof io.teaql.core.TransactionExecutor,"Native transaction capability required");
        ((io.teaql.core.TransactionExecutor)executor).executeInTransaction(context,()->{
            scalarOrder.auditAs("Remove Order line and recompute total atomically").save(context);
            target.auditAs("Remove Order line and recompute total atomically").save(context);
            return null;
        });
    }
    private static Object transition(UserContext context) {
        String target=System.getenv("ORDER_TARGET");long next=Long.parseLong(System.getenv("ORDER_NEXT_STATUS"));
        var rows=Q.customerOrders().withOrderNumberIs(target).selectOrderStatus().limit(2)
            .comment("Load full Order before state transition").purpose("Apply the Order lifecycle policy with original version").executeForList(context);
        require(rows.size()==1,"Expected one transition target");var order=rows.get(0);long current=status(order);
        var result=object("target",target,"from",current,"to",next,"observedVersion",E.customerOrder(order).getVersion().eval());
        if(!((current==1001 && (next==1002 || next==1003)) || (current==1002 && next==1003))) {result.put("outcome","rejected");result.put("reason","Transition not allowed");return result;}
        if(next==1002)order.updateOrderStatusToConfirmed();else order.updateOrderStatusToCancelled();
        order.auditAs("Apply an allowed Order status transition").save(context);result.put("outcome","committed");result.put("reason","");return result;
    }

    private static List<Object> pageRows(Iterable<CustomerOrder> orders,boolean preview) {
        var rows=new ArrayList<Object>();
        for(var order:orders) {
            var e=E.customerOrder(order);var row=object("id",e.getId().eval(),"orderNumber",e.getOrderNumber().eval(),"buyer",e.getBuyerReference().eval(),"totalMinor",e.getTotalMinor().eval(),"version",e.getVersion().eval());
            if(preview)row.put("items",order.getOrderItemList().stream().map(i->object("id",E.orderItem(i).getId().eval(),"sku",E.orderItem(i).getSkuCode().eval(),"lineTotalMinor",E.orderItem(i).getLineTotalMinor().eval(),"version",E.orderItem(i).getVersion().eval())).toList());
            rows.add(row);
        }
        return rows;
    }
    private static Object boundedPage(UserContext context) {
        int offset=Integer.parseInt(System.getenv("ORDER_PAGE_OFFSET")),limit=Integer.parseInt(System.getenv("ORDER_PAGE_LIMIT"));String buyer=System.getenv("ORDER_PAGE_BUYER");
        System.out.println("ORDER_PAGES_BEGIN");
        if(offset<0||limit<1||limit>3)return object("rejected",true,"reason","Page bounds must be offset >= 0 and limit in [1, 3]");
        var page=Q.customerOrders().withBuyerReferenceIs(buyer).orderByTotalMinorAscending().orderByIdAscending()
            .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(1)).offset(offset,limit).count()
            .comment("Read bounded Order pages").purpose("Compare filtered totals and per-order item previews").executeForList(context);
        return object("offset",offset,"limit",limit,"buyer",buyer,"total",page.getTotalCount(),"rows",pageRows(page,true));
    }
    private static Object exportPages(UserContext context) {
        String mode=System.getenv("ORDER_EXPORT_MODE");boolean complete=mode.equals("asc")||mode.equals("desc");
        require(List.of("asc","desc","miss","composite","predicate").contains(mode),"Unknown export mode");
        var pages=new ArrayList<Object>();int fallback=0,seek=0;boolean ended=false;System.out.println("ORDER_PAGES_BEGIN");
        for(int index=0;index<(complete?10:2);index++) {
            int offset=(index+(mode.equals("miss")?1:0))*3;String buyer=mode.equals("predicate")&&index==1?"BUYER-CONTROL":"BUYER-EXPORT";
            var query=Q.customerOrders().withBuyerReferenceIs(buyer);
            if(mode.equals("composite"))query.orderByTotalMinorAscending().orderByIdAscending();
            else if(mode.equals("desc"))query.orderByIdDescending();else query.orderByIdAscending();
            System.out.println("ORDER_EXPORT_PAGE "+index);
            var page=query.offset(offset,3).optimizeForContinuousPageFetch("order-export-"+mode,300).count()
                .comment("Export Order pages").purpose("Export complete bounded Order identities through one trusted context").executeForList(context);
            String plan=(String)context.getAttribute(io.teaql.core.sql.portable.PortableSQLRepository.CONTINUOUS_PAGE_PLAN);
            require(plan!=null,"Missing native cursor observation");if(plan.equals("CURSOR_SEEK"))seek++;else if(plan.startsWith("OFFSET_FALLBACK:"))fallback++;
            pages.add(object("offset",offset,"buyer",buyer,"rows",pageRows(page,false),"total",page.getTotalCount(),"plan",plan));
            if(complete&&page.isEmpty()){ended=true;break;}
        }
        require(!complete||ended,"Export page budget exhausted");return object("mode",mode,"pages",pages,"fallbackCount",fallback,"seekCount",seek);
    }

    private static void worker(UserContext context) throws Exception {
        String worker=System.getenv("ORDER_WORKER"), target=System.getenv("ORDER_TARGET"), note=System.getenv("ORDER_NOTE");
        var rows=Q.customerOrders().withOrderNumberIs(target).limit(2)
            .comment("Load complete Order before write barrier").purpose("Retain original version for concurrent note update").executeForList(context);
        require(rows.size()==1,"Expected one worker order");
        var order=rows.get(0);
        var result=object("worker",worker,"target",target,"note",note,"pid",ProcessHandle.current().pid(),
            "observedVersion",E.customerOrder(order).getVersion().eval(),"observedNote",E.customerOrder(order).getOrderNote().eval());
        var barrier=Path.of(System.getenv("ORDER_BARRIER"));
        var temporary=barrier.resolve(worker+".tmp");
        java.nio.file.Files.writeString(temporary,JSON.writeValueAsString(result));
        java.nio.file.Files.move(temporary,barrier.resolve(worker+".ready"));
        long deadline=System.nanoTime()+java.util.concurrent.TimeUnit.SECONDS.toNanos(45);
        while(!java.nio.file.Files.exists(barrier.resolve(System.getenv("ORDER_RELEASE")))) {
            require(System.nanoTime()<deadline,"Worker barrier timeout"); Thread.sleep(10);
        }
        order.updateOrderNote(note);
        String outcome="committed", reason="";
        try { order.auditAs("Revise Order note with optimistic version").save(context); }
        catch(io.teaql.core.ConcurrentModifyException error) { outcome="conflict";reason=error.toString(); }
        result.put("outcome",outcome);result.put("conflictReason",reason);
        System.out.println("ORDER_WORKER "+JSON.writeValueAsString(result));
    }

    private static final class ObservedIds implements io.teaql.core.IdSetStore {
        final io.teaql.core.IdSetStore delegate=new io.teaql.core.sql.portable.InMemoryIdSetStore();
        final List<Object> events=new ArrayList<>();String lastKey;
        public Optional<io.teaql.core.RetainedIdSet> get(String key) {lastKey=key;var value=delegate.get(key);events.add(object("op","get","key",key,"hit",value.isPresent()));return value;}
        public void put(io.teaql.core.RetainedIdSet value) {delegate.put(value);events.add(object("op","put","key",value.queryKey(),"ids",value.ids()));}
        public void invalidate(String key) {delegate.invalidate(key);events.add(object("op","invalidate","key",key));}
    }
    private static Object retainedPages(UserContext context) throws Exception {
        String mode=System.getenv("ORDER_RETAINED_MODE");var store=new ObservedIds();context.putAttribute(io.teaql.core.IdSetStore.class.getName(),store);
        int[] offsets=switch(mode){case "jumps"->new int[]{6,0,3,9,0};case "empty","expiry"->new int[]{0,3};case "overflow"->new int[]{3,0};case "isolation"->new int[]{0,0,3};case "invalidate"->new int[]{0,3,6};default->throw new IllegalArgumentException(mode);};
        var pages=new ArrayList<Object>();System.out.println("ORDER_INSIGHTS_BEGIN");
        for(int index=0;index<offsets.length;index++) {
            if(mode.equals("expiry")&&index==1){long start=System.nanoTime();Thread.sleep(1300);store.events.add(object("op","wait","elapsedMs",(System.nanoTime()-start)/1000000));}
            if(mode.equals("invalidate")&&index==2)store.invalidate(Objects.requireNonNull(store.lastKey));
            String buyer=mode.equals("empty")?"BUYER-MISSING":mode.equals("isolation")&&index==1?"BUYER-CONTROL":"BUYER-EXPORT";
            System.out.println("ORDER_RETAINED_PAGE "+index);
            var page=Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs("USD").orderByTotalMinorAscending().orderByIdAscending()
                .offset(offsets[index],3).optimizePaginationWithIdSet("order-retained-"+mode,mode.equals("expiry")?1:300,mode.equals("overflow")?4:20).count()
                .comment("Read retained Order IDs").purpose("Verify random jumps and retained-set lifecycle").executeForList(context);
            pages.add(object("offset",offsets[index],"buyer",buyer,"currency","USD","rows",pageRows(page,false),"total",page.getTotalCount(),
                "plan",context.getAttribute(io.teaql.core.sql.portable.PortableSQLRepository.ID_SET_PLAN),"observedCount",context.getAttribute(io.teaql.core.sql.portable.PortableSQLRepository.ID_SET_COUNT)));
        }
        return object("mode",mode,"pages",pages,"events",store.events);
    }
    private static Object orderSummary(UserContext context) {
        String buyer=System.getenv("ORDER_SUMMARY_BUYER"),currency=System.getenv("ORDER_SUMMARY_CURRENCY");int minimum=Integer.parseInt(System.getenv("ORDER_SUMMARY_MINIMUM"));
        System.out.println("ORDER_INSIGHTS_BEGIN");
        var groups=Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
            .groupByOrderStatusAs("statusId").countAs("count").sumTotalMinorAs("totalMinor").limit(4)
            .comment("Summarize filtered Order amounts by status").purpose("Compute same-currency Order summaries in the provider").aggregation(context).toList();
        var summary=Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
            .countAs("count").sumTotalMinorAs("totalMinor").limit(1)
            .comment("Summarize the complete filtered Order set").purpose("Compare exact counts and money independent of page size").aggregation(context).toList();
        var sets=new ArrayList<Object>();Object rows=null;long total=0;
        for(boolean all:new boolean[]{true,false}) {
            var page=Q.customerOrders().withBuyerReferenceIs(buyer).withCurrencyCodeIs(currency).withTotalMinorGreaterThanOrEqualTo(minimum)
                .facetByOrderStatusAs("statuses",Q.orderStatusesWithMinimalFields().selectCode().countCustomerOrdersAs("count").limit(4),all)
                .selectOrderItemListWith(Q.orderItems().orderBySkuCodeAscending().orderByIdAscending().limit(1)).orderByIdAscending().limit(3).count()
                .comment("Read Order status buckets and bounded item previews").purpose("Keep rows facets and counts on the same filtered set").executeForList(context);
            io.teaql.core.SmartList<com.example.orderworkflowservice.orderstatus.OrderStatus> facets=page.getFacet("statuses");var buckets=new TreeMap<String,Object>();
            for(var status:facets)buckets.put(E.orderStatus(status).getCode().eval(),status.getDynamicProperty("count"));sets.add(buckets);
            if(all){rows=pageRows(page,true);total=page.getTotalCount();}
        }
        return object("buyer",buyer,"currency",currency,"minimum",minimum,"groups",groups,"summary",summary,"allBuckets",sets.get(0),"matchedBuckets",sets.get(1),"rows",rows,"total",total);
    }

    public static void run(String phase, UserContext context) {
        try { execute(phase,context); }
        catch (Exception error) { throw new IllegalStateException("Order verification failed",error); }
    }
    private static void execute(String phase, UserContext context) throws Exception {
        switch (phase) {
            case "insights-retained": report(phase,retainedPages(context));break;
            case "insights-summary": report(phase,orderSummary(context));break;
            case "pages-bounded": report(phase,boundedPage(context));break;
            case "pages-export": report(phase,exportPages(context));break;
            case "complete-read": report(phase,completeRead(context)); break;
            case "omission-probe": omitPreview(context);report(phase,object("previewCount",1));break;
            case "remove-line": removeLine(context,false);report(phase,object("removed","SKU-PEN"));break;
            case "remove-conflict":
                try {removeLine(context,true);throw new IllegalStateException("Stale deletion accepted");}
                catch(io.teaql.core.ConcurrentModifyException error) {report(phase,object("rejected",true,"reason",error.toString()));}break;
            case "transition": report(phase,transition(context));break;
            case "guard-edit":
                try {edit(context,3,false);throw new IllegalStateException("Non-DRAFT edit accepted");}
                catch(IllegalStateException error) {require("Only DRAFT orders can be edited".equals(error.getMessage()),"Unexpected edit failure");report(phase,object("rejected",true,"reason",error.getMessage()));}break;
            case "bootstrap": break;
            case "seed": {
                var fixture=JSON.readTree(Path.of(System.getenv("ORDER_FIXTURE")).toFile());
                var roots=Q.commercePlatformsWithMinimalFields().limit(2)
                    .comment("Read initialized commerce root").purpose("Seed Order fixture").executeForList(context);
                require(roots.size()==1,"Expected one commerce root");
                for (var input:fixture.get("orders")) {
                    var order=Q.customerOrders().comment("Create fixture order").purpose("Seed Order workflow").newEntity(context);
                    order.updateCommercePlatform(roots.get(0)); switch(input.get("order_status").asText()){case "DRAFT"->order.updateOrderStatusToDraft();case "CONFIRMED"->order.updateOrderStatusToConfirmed();case "CANCELLED"->order.updateOrderStatusToCancelled();default->throw new IllegalArgumentException("Unknown fixture status");}
                    order.updateOrderNumber(input.get("order_number").asText());
                    order.updateBuyerReference(input.get("buyer_reference").asText());
                    order.updateCurrencyCode(input.get("currency_code").asText());
                    order.updateTotalMinor(input.get("total_minor").asInt());
                    order.updateOrderNote(input.get("order_note").isNull()?null:input.get("order_note").asText());
                    order.auditAs(SEED).save(context);
                    for(var line:input.get("items")) {
                        var item=Q.orderItems().comment("Create fixture order item").purpose("Seed Order workflow").newEntity(context);
                        item.updateCustomerOrder(order); item.updateSkuCode(line.get("sku_code").asText());
                        item.updateProductName(line.get("product_name").asText()); item.updateQuantity(line.get("quantity").asInt());
                        item.updateUnitPriceMinor(line.get("unit_price_minor").asInt()); item.updateLineTotalMinor(line.get("line_total_minor").asInt());
                        item.auditAs(SEED).save(context);
                    }
                }
                break;
            }
            // scenario: draft-graph, restart-readback
            case "worker": worker(context); break;
            case "p1-read": case "draft-graph": case "restart-readback": report(phase,graph(context)); break;
            // scenario: note-value, note-null, note-empty
            case "note-value": case "note-null": case "note-empty": {
                String number=phase.equals("note-null")?"ORD-2026-1002":phase.equals("note-empty")?"ORD-2026-1003":"ORD-2026-1001";
                var order=Q.customerOrdersWithMinimalFields().selectOrderNote().withOrderNumberIs(number).limit(2)
                    .comment("Select nullable order note").purpose("Verify loaded note and null-only default").executeForOne(context);
                var expression=E.customerOrder(Objects.requireNonNull(order)).getOrderNote();
                report(phase,object("value",expression.eval(),"fallback",expression.orIfNull("No note"))); break;
            }
            // scenario: note-not-loaded
            case "note-not-loaded": {
                var order=Q.customerOrdersWithMinimalFields().selectOrderNumber().withOrderNumberIs("ORD-2026-1001").limit(2)
                    .comment("Omit order note from projection").purpose("Expose missing-field errors").executeForOne(context);
                var expression=E.customerOrder(Objects.requireNonNull(order)).getOrderNote();
                report(phase,object("eval",missing(()->expression.eval()),"fallback",missing(()->expression.orIfNull("No note")))); break;
            }
            // scenario: invalid-quantity
            case "invalid-quantity": {
                var results=new ArrayList<Object>();
                for(double quantity:new double[]{0,-1,1.5,101}) {
                    try { edit(context,quantity,false); throw new IllegalStateException("Invalid quantity accepted"); }
                    catch(IllegalArgumentException error) { results.add(object("quantity",quantity,"rejected",true,"reason",error.getMessage())); }
                }
                report(phase,results); break;
            }
            // scenario: draft-edit
            case "draft-edit": edit(context,3,false); report(phase,graph(context)); break;
            case "rollback-probe": {
                try { edit(context,3,true); throw new IllegalStateException("Stale child accepted"); }
                catch(io.teaql.core.ConcurrentModifyException error) { report(phase,object("rejected",true,"reason",error.toString())); }
                break;
            }
            default: throw new IllegalArgumentException("Unknown phase: "+phase);
        }
        System.out.println("ORDER_OK phase="+phase);
    }
}
