package main

import (
	stdcontext "context"
	"encoding/json"
	"fmt"
	"github.com/teaql/teaql-golang/runtime"
	"math"
	. "order-workflow-service-core-workspace/lib"
	"order-workflow-service-core-workspace/lib/customer_order"
	"order-workflow-service-core-workspace/lib/order_item"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

const seedReason = "Seed the Order workflow fixture"
const editReason = "Edit draft Order quantity and totals atomically"

type object = map[string]any
type fixture struct {
	Orders []struct {
		Number   string  `json:"order_number"`
		Status   string  `json:"order_status"`
		Buyer    string  `json:"buyer_reference"`
		Currency string  `json:"currency_code"`
		Total    int64   `json:"total_minor"`
		Note     *string `json:"order_note"`
		Items    []struct {
			SKU      string `json:"sku_code"`
			Name     string `json:"product_name"`
			Quantity int64  `json:"quantity"`
			Price    int64  `json:"unit_price_minor"`
			Total    int64  `json:"line_total_minor"`
		} `json:"items"`
	} `json:"orders"`
}

func required[T any](value T, present bool) T {
	if !present {
		panic("Required loaded value is null")
	}
	return value
}
func nullable[T any](value T, present bool) any {
	if !present {
		return nil
	}
	return value
}
func check(err error) {
	if err != nil {
		panic(err)
	}
}
func report(name string, value any) {
	data, err := json.Marshal(object{"case": name, "value": value})
	check(err)
	fmt.Println("ORDER_CASE " + string(data))
}
func missing(call func()) (result object) {
	defer func() {
		if e := recover(); e != nil {
			result = object{"type": fmt.Sprintf("%T", e), "message": fmt.Sprint(e)}
		}
	}()
	call()
	return object{"type": "UnexpectedSuccess", "message": "NotLoaded did not fail"}
}
func graph(context *runtime.UserContext) []object {
	rows, err := Q.CustomerOrders().OrderByOrderNumberAsc().OrderByIdAsc().
		SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAsc().OrderByIdAsc().Limit(101)).Limit(10).
		Comment("Read bounded full Order graphs").Purpose("Verify persisted Order workflow results").ExecuteForList(context)
	check(err)
	result := []object{}
	for _, order := range rows.Data {
		e := customer_order.NewCustomerOrderExpression(order)
		items := []object{}
		for _, item := range order.OrderItemList().Items() {
			x := order_item.NewOrderItemExpression(item)
			items = append(items, object{"sku": required(x.SkuCode().Eval()), "productName": required(x.ProductName().Eval()), "quantity": required(x.Quantity().Eval()), "unitPriceMinor": required(x.UnitPriceMinor().Eval()), "lineTotalMinor": required(x.LineTotalMinor().Eval()), "version": required(x.Version().Eval())})
		}
		result = append(result, object{"orderNumber": required(e.OrderNumber().Eval()), "totalMinor": required(e.TotalMinor().Eval()), "note": nullable(e.OrderNote().Eval()), "version": required(e.Version().Eval()), "items": items})
	}
	return result
}
func edit(context *runtime.UserContext, quantity float64, rollback bool) error {
	if math.IsNaN(quantity) || math.IsInf(quantity, 0) || math.Trunc(quantity) != quantity || quantity < 1 || quantity > 100 {
		return fmt.Errorf("Quantity must be an integer in [1, 100]")
	}
	rows, err := Q.CustomerOrders().WithOrderNumberIs("ORD-2026-1001").
		SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAsc().OrderByIdAsc().Limit(101)).Limit(2).
		Comment("Load full draft and bounded full items").Purpose("Validate and edit one draft order").ExecuteForList(context)
	if err != nil {
		return err
	}
	if len(rows.Data) != 1 {
		return fmt.Errorf("Expected one draft order")
	}
	order := rows.Data[0]
	if required(customer_order.NewCustomerOrderExpression(order).OrderStatusId().Eval()) != 1001 {
		return fmt.Errorf("Only DRAFT orders can be edited")
	}
	if required(customer_order.NewCustomerOrderExpression(order).CurrencyCode().Eval()) != "USD" {
		return fmt.Errorf("Unsupported currency")
	}
	items := order.OrderItemList().Items()
	if len(items) > 100 {
		return fmt.Errorf("Order item limit exceeded")
	}
	var selected *order_item.OrderItem
	var total int64
	for _, item := range items {
		e := order_item.NewOrderItemExpression(item)
		price := required(e.UnitPriceMinor().Eval())
		units := required(e.Quantity().Eval())
		if price < 0 || price > 100000 || units < 1 || units > 100 || required(e.LineTotalMinor().Eval()) != price*units {
			return fmt.Errorf("Invalid persisted item amount")
		}
		if required(e.SkuCode().Eval()) == "SKU-NOTEBOOK" {
			if selected != nil {
				return fmt.Errorf("Duplicate SKU")
			}
			selected = item
			units = int64(quantity)
		}
		total += price * units
	}
	if selected == nil || total > 1000000000 {
		return fmt.Errorf("Missing item or invalid total")
	}
	if rollback {
		winner, err := Q.OrderItems().WithIdIs(required(order_item.NewOrderItemExpression(selected).Id().Eval())).Limit(2).
			Comment("Load independent item revision").Purpose("Probe atomic rollback on stale child").ExecuteForOne(context)
		if err != nil {
			return err
		}
		if winner == nil {
			return fmt.Errorf("Missing winner")
		}
		winner.UpdateProductName("Notebook (concurrent winner)")
		if _, err = winner.AuditAs("Advance Order item before stale graph probe").Save(context); err != nil {
			return err
		}
	}
	selected.UpdateQuantity(int64(quantity))
	selected.UpdateLineTotalMinor(int64(quantity) * required(order_item.NewOrderItemExpression(selected).UnitPriceMinor().Eval()))
	order.UpdateTotalMinor(total)
	fmt.Println("ORDER_GRAPH_ATTEMPT")
	_, err = order.AuditAs(editReason).Save(context)
	return err
}
func completeRead(context *runtime.UserContext) object {
	orders, err := Q.CustomerOrders().OrderByOrderNumberAsc().OrderByIdAsc().Limit(10).
		Comment("Read authoritative Order states").Purpose("Verify transition persistence after restart").ExecuteForList(context)
	check(err)
	deleted, err := Q.OrderItems().DeletedRowsOnly().WithSkuCodeIs("SKU-PEN").Limit(10).
		Comment("Read retained deleted Order lines").Purpose("Verify explicit soft deletion after restart").ExecuteForList(context)
	check(err)
	states := []object{}
	for _, o := range orders.Data {
		e := customer_order.NewCustomerOrderExpression(o)
		states = append(states, object{"orderNumber": required(e.OrderNumber().Eval()), "statusId": required(e.OrderStatusId().Eval()), "version": required(e.Version().Eval())})
	}
	tombstones := []object{}
	for _, i := range deleted.Data {
		e := order_item.NewOrderItemExpression(i)
		tombstones = append(tombstones, object{"sku": required(e.SkuCode().Eval()), "version": required(e.Version().Eval())})
	}
	return object{"graph": graph(context), "states": states, "deleted": tombstones}
}
func omitPreview(context *runtime.UserContext) {
	rows, err := 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)
	check(err)
	if len(rows.Data) != 1 || len(rows.Data[0].OrderItemList().Items()) != 1 {
		panic("Expected one preview line")
	}
	order := rows.Data[0]
	note := "Edited through an item preview"
	order.UpdateOrderNote(&note)
	_, err = order.AuditAs("Edit Order note without replacing its item collection").Save(context)
	check(err)
}
func removeLine(context *runtime.UserContext, rollback bool) error {
	rows, err := Q.CustomerOrders().WithOrderNumberIs("ORD-2026-1001").
		SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAsc().OrderByIdAsc().Limit(101)).Limit(2).
		Comment("Load complete Order for explicit line removal").Purpose("Recompute total from all retained items").ExecuteForList(context)
	if err != nil {
		return err
	}
	if len(rows.Data) != 1 {
		return fmt.Errorf("Expected one order")
	}
	order := rows.Data[0]
	if required(customer_order.NewCustomerOrderExpression(order).OrderStatusId().Eval()) != 1001 {
		return fmt.Errorf("Only DRAFT orders can be edited")
	}
	items := order.OrderItemList().Items()
	if len(items) <= 1 || len(items) > 100 {
		return fmt.Errorf("Invalid full item count")
	}
	var target *order_item.OrderItem
	var total int64
	for _, item := range items {
		e := order_item.NewOrderItemExpression(item)
		price, units := required(e.UnitPriceMinor().Eval()), required(e.Quantity().Eval())
		if price < 0 || price > 100000 || units < 1 || units > 100 || required(e.LineTotalMinor().Eval()) != price*units {
			return fmt.Errorf("Invalid persisted item amount")
		}
		if required(e.SkuCode().Eval()) == "SKU-PEN" {
			if target != nil {
				return fmt.Errorf("Duplicate target")
			}
			target = item
		} else {
			total += price * units
		}
	}
	if target == nil || total > 1000000000 {
		return fmt.Errorf("Missing target or total overflow")
	}
	if rollback {
		winner, err := Q.OrderItems().WithIdIs(required(order_item.NewOrderItemExpression(target).Id().Eval())).Limit(2).
			Comment("Load independent deletion competitor").Purpose("Test rollback when explicit deletion is stale").ExecuteForOne(context)
		if err != nil {
			return err
		}
		if winner == nil {
			return fmt.Errorf("Missing winner")
		}
		winner.UpdateProductName("Pen (concurrent winner)")
		if _, err = winner.AuditAs("Advance Order item before stale deletion probe").Save(context); err != nil {
			return err
		}
	}
	target.MarkForDeletion()
	order.UpdateTotalMinor(total)
	fmt.Println("ORDER_REMOVAL_ATTEMPT")
	_, err = order.AuditAs("Remove Order line and recompute total atomically").Save(context)
	return err
}
func transition(context *runtime.UserContext) object {
	target := os.Getenv("ORDER_TARGET")
	next, err := strconv.ParseUint(os.Getenv("ORDER_NEXT_STATUS"), 10, 64)
	check(err)
	rows, err := Q.CustomerOrders().WithOrderNumberIs(target).Limit(2).
		Comment("Load full Order before state transition").Purpose("Apply the Order lifecycle policy with original version").ExecuteForList(context)
	check(err)
	if len(rows.Data) != 1 {
		panic("Expected one target")
	}
	order := rows.Data[0]
	e := customer_order.NewCustomerOrderExpression(order)
	current := required(e.OrderStatusId().Eval())
	result := object{"target": target, "from": current, "to": next, "observedVersion": required(e.Version().Eval())}
	if !((current == 1001 && (next == 1002 || next == 1003)) || (current == 1002 && next == 1003)) {
		result["outcome"] = "rejected"
		result["reason"] = "Transition not allowed"
		return result
	}
	if next == 1002 {
		order.UpdateOrderStatusToConfirmed()
	} else {
		order.UpdateOrderStatusToCancelled()
	}
	_, err = order.AuditAs("Apply an allowed Order status transition").Save(context)
	check(err)
	result["outcome"] = "committed"
	result["reason"] = ""
	return result
}

func pageRows(orders []*customer_order.CustomerOrder, preview bool) []object {
	rows := []object{}
	for _, o := range orders {
		e := customer_order.NewCustomerOrderExpression(o)
		row := object{"id": required(e.Id().Eval()), "orderNumber": required(e.OrderNumber().Eval()), "buyer": required(e.BuyerReference().Eval()), "totalMinor": required(e.TotalMinor().Eval()), "version": required(e.Version().Eval())}
		if preview {
			items := []object{}
			for _, i := range o.OrderItemList().Items() {
				x := order_item.NewOrderItemExpression(i)
				items = append(items, object{"id": required(x.Id().Eval()), "sku": required(x.SkuCode().Eval()), "lineTotalMinor": required(x.LineTotalMinor().Eval()), "version": required(x.Version().Eval())})
			}
			row["items"] = items
		}
		rows = append(rows, row)
	}
	return rows
}
func boundedPage(context *runtime.UserContext) object {
	offset, err := strconv.ParseInt(os.Getenv("ORDER_PAGE_OFFSET"), 10, 64)
	check(err)
	limit, err := strconv.ParseInt(os.Getenv("ORDER_PAGE_LIMIT"), 10, 64)
	check(err)
	buyer := os.Getenv("ORDER_PAGE_BUYER")
	fmt.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]"}
	}
	page, err := Q.CustomerOrders().WithBuyerReferenceIs(buyer).OrderByTotalMinorAsc().OrderByIdAsc().
		SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAsc().OrderByIdAsc().Limit(1)).Offset(uint64(offset)).Limit(uint64(limit)).Count().
		Comment("Read bounded Order pages").Purpose("Compare filtered totals and per-order item previews").ExecuteForList(context)
	check(err)
	if page.TotalCount == nil {
		panic("Missing exact total")
	}
	return object{"offset": offset, "limit": limit, "buyer": buyer, "rows": pageRows(page.Data, true), "total": *page.TotalCount}
}
func exportPages(context *runtime.UserContext) object {
	mode := os.Getenv("ORDER_EXPORT_MODE")
	complete := mode == "asc" || mode == "desc"
	if !complete && mode != "miss" && mode != "composite" && mode != "predicate" {
		panic("Unknown export mode")
	}
	pages := []object{}
	fallback, seek := 0, 0
	ended := false
	steps := 2
	if complete {
		steps = 10
	}
	fmt.Println("ORDER_PAGES_BEGIN")
	for index := 0; index < steps; index++ {
		offset := index * 3
		if mode == "miss" {
			offset += 3
		}
		buyer := "BUYER-EXPORT"
		if mode == "predicate" && index == 1 {
			buyer = "BUYER-CONTROL"
		}
		query := Q.CustomerOrders().WithBuyerReferenceIs(buyer)
		if mode == "composite" {
			query = query.OrderByTotalMinorAsc().OrderByIdAsc()
		} else if mode == "desc" {
			query = query.OrderByIdDesc()
		} else {
			query = query.OrderByIdAsc()
		}
		fmt.Println("ORDER_EXPORT_PAGE", index)
		page, err := query.Offset(uint64(offset)).Limit(3).OptimizeForContinuousPageFetchWith("order-export-"+mode, 300).Count().
			Comment("Export Order pages").Purpose("Export complete bounded Order identities through one trusted context").ExecuteForList(context)
		check(err)
		if page.TotalCount == nil {
			panic("Missing exact total")
		}
		plan := context.ContinuousPagePlan()
		if plan == "" {
			panic("Missing native cursor observation")
		}
		if plan == "CURSOR_SEEK" {
			seek++
		} else if strings.HasPrefix(plan, "OFFSET_FALLBACK:") {
			fallback++
		}
		pages = append(pages, object{"offset": offset, "buyer": buyer, "rows": pageRows(page.Data, false), "total": *page.TotalCount, "plan": plan})
		if complete && len(page.Data) == 0 {
			ended = true
			break
		}
	}
	if complete && !ended {
		panic("Export page budget exhausted")
	}
	return object{"mode": mode, "pages": pages, "fallbackCount": fallback, "seekCount": seek}
}

func worker(context *runtime.UserContext) {
	name, target, note := os.Getenv("ORDER_WORKER"), os.Getenv("ORDER_TARGET"), os.Getenv("ORDER_NOTE")
	rows, err := Q.CustomerOrders().WithOrderNumberIs(target).Limit(2).
		Comment("Load complete Order before write barrier").Purpose("Retain original version for concurrent note update").ExecuteForList(context)
	check(err)
	if len(rows.Data) != 1 {
		panic("Expected one worker order")
	}
	order := rows.Data[0]
	e := customer_order.NewCustomerOrderExpression(order)
	result := object{"worker": name, "target": target, "note": note, "pid": os.Getpid(), "observedVersion": required(e.Version().Eval()), "observedNote": nullable(e.OrderNote().Eval())}
	barrier := os.Getenv("ORDER_BARRIER")
	data, err := json.Marshal(result)
	check(err)
	check(os.WriteFile(filepath.Join(barrier, name+".tmp"), data, 0600))
	check(os.Rename(filepath.Join(barrier, name+".tmp"), filepath.Join(barrier, name+".ready")))
	deadline := time.Now().Add(45 * time.Second)
	for {
		_, err := os.Stat(filepath.Join(barrier, os.Getenv("ORDER_RELEASE")))
		if err == nil {
			break
		}
		if !os.IsNotExist(err) {
			panic(err)
		}
		if time.Now().After(deadline) {
			panic("Worker barrier timeout")
		}
		time.Sleep(10 * time.Millisecond)
	}
	order.UpdateOrderNote(&note)
	_, err = order.AuditAs("Revise Order note with optimistic version").Save(context)
	result["outcome"] = "committed"
	result["conflictReason"] = ""
	if err != nil {
		result["outcome"] = "conflict"
		result["conflictReason"] = err.Error()
	}
	data, err = json.Marshal(result)
	check(err)
	fmt.Println("ORDER_WORKER " + string(data))
}

type observedIDs struct {
	delegate runtime.IDSetStore
	events   []object
	lastKey  string
}

func (s *observedIDs) GetIDSet(ctx stdcontext.Context, key string) (*runtime.RetainedIDSet, error) {
	s.lastKey = key
	v, e := s.delegate.GetIDSet(ctx, key)
	s.events = append(s.events, object{"op": "get", "key": key, "hit": v != nil})
	return v, e
}
func (s *observedIDs) PutIDSet(ctx stdcontext.Context, v *runtime.RetainedIDSet) error {
	e := s.delegate.PutIDSet(ctx, v)
	ids := append([]uint64{}, v.IDs...)
	s.events = append(s.events, object{"op": "put", "key": v.QueryKey, "ids": ids})
	return e
}
func (s *observedIDs) InvalidateIDSet(ctx stdcontext.Context, key string) error {
	e := s.delegate.InvalidateIDSet(ctx, key)
	s.events = append(s.events, object{"op": "invalidate", "key": key})
	return e
}
func retainedPages(context *runtime.UserContext) object {
	mode := os.Getenv("ORDER_RETAINED_MODE")
	store := &observedIDs{delegate: runtime.NewInMemoryIDSetStore(), events: []object{}}
	context.SetIDSetStore(store)
	offsets := map[string][]int{"jumps": {6, 0, 3, 9, 0}, "empty": {0, 3}, "overflow": {3, 0}, "isolation": {0, 0, 3}, "expiry": {0, 3}, "invalidate": {0, 3, 6}}[mode]
	if offsets == nil {
		panic("Unknown retained mode")
	}
	pages := []object{}
	fmt.Println("ORDER_INSIGHTS_BEGIN")
	for index, offset := range offsets {
		if mode == "expiry" && index == 1 {
			start := time.Now()
			time.Sleep(1300 * time.Millisecond)
			store.events = append(store.events, object{"op": "wait", "elapsedMs": time.Since(start).Milliseconds()})
		}
		if mode == "invalidate" && index == 2 {
			if store.lastKey == "" {
				panic("No retained key")
			}
			check(store.InvalidateIDSet(stdcontext.Background(), store.lastKey))
		}
		buyer := "BUYER-EXPORT"
		if mode == "empty" {
			buyer = "BUYER-MISSING"
		} else if mode == "isolation" && index == 1 {
			buyer = "BUYER-CONTROL"
		}
		ttl, maxIDs := uint64(300), uint64(20)
		if mode == "expiry" {
			ttl = 1
		}
		if mode == "overflow" {
			maxIDs = 4
		}
		fmt.Println("ORDER_RETAINED_PAGE", index)
		page, err := Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs("USD").OrderByTotalMinorAsc().OrderByIdAsc().Offset(uint64(offset)).Limit(3).OptimizePaginationWithIDSetConfig("order-retained-"+mode, ttl, maxIDs).Count().
			Comment("Read retained Order IDs").Purpose("Verify random jumps and retained-set lifecycle").ExecuteForList(context)
		check(err)
		count, _ := context.IDSetCount()
		pages = append(pages, object{"offset": offset, "buyer": buyer, "currency": "USD", "rows": pageRows(page.Data, false), "total": *page.TotalCount, "plan": context.IDSetPlan(), "observedCount": count})
	}
	return object{"mode": mode, "pages": pages, "events": store.events}
}
func orderSummary(context *runtime.UserContext) object {
	buyer, currency := os.Getenv("ORDER_SUMMARY_BUYER"), os.Getenv("ORDER_SUMMARY_CURRENCY")
	minimum, err := strconv.ParseInt(os.Getenv("ORDER_SUMMARY_MINIMUM"), 10, 64)
	check(err)
	fmt.Println("ORDER_INSIGHTS_BEGIN")
	groups, err := Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs(currency).WithTotalMinorGreaterThanOrEqualTo(minimum).GroupByOrderStatus().CountAs("count").SumTotalMinorAs("totalMinor").Limit(4).
		Comment("Summarize filtered Order amounts by status").Purpose("Compute same-currency Order summaries in the provider").ExecuteRecords(context)
	check(err)
	distribution := []object{}
	for _, r := range groups {
		distribution = append(distribution, object{"statusId": required(r["order_status"].TryU64()), "count": required(r["count"].TryU64()), "totalMinor": required(r["totalMinor"].TryF64())})
	}
	summary, err := 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").ExecuteRecords(context)
	check(err)
	totals := []object{}
	for _, r := range summary {
		totals = append(totals, object{"count": required(r["count"].TryU64()), "totalMinor": nullable(r["totalMinor"].TryF64())})
	}
	sets := []object{}
	rows := []object{}
	var total uint64
	for _, all := range []bool{true, false} {
		page, err := Q.CustomerOrders().WithBuyerReferenceIs(buyer).WithCurrencyCodeIs(currency).WithTotalMinorGreaterThanOrEqualTo(minimum).
			FacetByOrderStatusAs("statuses", Q.OrderStatusesMinimal().SelectCode().CountCustomerOrdersAs("count").Limit(4), all).
			SelectOrderItemListWith(Q.OrderItems().OrderBySkuCodeAsc().OrderByIdAsc().Limit(1)).OrderByIdAsc().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)
		check(err)
		buckets := object{}
		facet := required(page.Facet("statuses"))
		for _, r := range facet.Data {
			buckets[required(r["code"].TryText())] = required(r["count"].TryU64())
		}
		sets = append(sets, buckets)
		if all {
			rows = pageRows(page.Data, true)
			total = *page.TotalCount
		}
	}
	return object{"buyer": buyer, "currency": currency, "minimum": minimum, "groups": distribution, "summary": totals, "allBuckets": sets[0], "matchedBuckets": sets[1], "rows": rows, "total": total}
}

func main() {
	phase := os.Args[1]
	context, err := ServiceRuntimeFromEnv()
	check(err)
	if phase != "worker" {
		check(EnsureSchema(context))
	}
	switch phase {
	case "insights-retained":
		report(phase, retainedPages(context))
	case "insights-summary":
		report(phase, orderSummary(context))
	case "pages-bounded":
		report(phase, boundedPage(context))
	case "pages-export":
		report(phase, exportPages(context))
	case "complete-read":
		report(phase, completeRead(context))
	case "omission-probe":
		omitPreview(context)
		report(phase, object{"previewCount": 1})
	case "remove-line":
		check(removeLine(context, false))
		report(phase, object{"removed": "SKU-PEN"})
	case "remove-conflict":
		err := removeLine(context, true)
		if err == nil {
			panic("Stale deletion accepted")
		}
		report(phase, object{"rejected": true, "reason": err.Error()})
	case "transition":
		report(phase, transition(context))
	case "guard-edit":
		err := edit(context, 3, false)
		if err == nil || err.Error() != "Only DRAFT orders can be edited" {
			panic("Expected state policy rejection")
		}
		report(phase, object{"rejected": true, "reason": err.Error()})

	case "worker":
		worker(context)
	case "bootstrap":
	case "seed":
		data, err := os.ReadFile(os.Getenv("ORDER_FIXTURE"))
		check(err)
		var f fixture
		check(json.Unmarshal(data, &f))
		for _, input := range f.Orders {
			order := Q.CustomerOrders().Comment("Create fixture order").Purpose("Seed Order workflow").NewEntity(context)
			order.UpdateCommercePlatformId(1)
			switch input.Status {
			case "CONFIRMED":
				order.UpdateOrderStatusToConfirmed()
			case "CANCELLED":
				order.UpdateOrderStatusToCancelled()
			case "DRAFT":
				order.UpdateOrderStatusToDraft()
			default:
				panic("Unknown fixture status")
			}
			order.UpdateOrderNumber(input.Number)
			order.UpdateBuyerReference(input.Buyer)
			order.UpdateCurrencyCode(input.Currency)
			order.UpdateTotalMinor(input.Total)
			order.UpdateOrderNote(input.Note)
			saved, err := order.AuditAs(seedReason).Save(context)
			check(err)
			id := required(customer_order.NewCustomerOrderExpression(saved).Id().Eval())
			for _, line := range input.Items {
				item := Q.OrderItems().Comment("Create fixture item").Purpose("Seed Order workflow").NewEntity(context)
				item.UpdateCustomerOrderId(id)
				item.UpdateSkuCode(line.SKU)
				item.UpdateProductName(line.Name)
				item.UpdateQuantity(line.Quantity)
				item.UpdateUnitPriceMinor(line.Price)
				item.UpdateLineTotalMinor(line.Total)
				_, err := item.AuditAs(seedReason).Save(context)
				check(err)
			}
		}
	// scenario: draft-graph, restart-readback
	case "p1-read", "draft-graph", "restart-readback":
		report(phase, graph(context))
	// scenario: note-value, note-null, note-empty
	case "note-value", "note-null", "note-empty":
		number := "ORD-2026-1001"
		if phase == "note-null" {
			number = "ORD-2026-1002"
		}
		if phase == "note-empty" {
			number = "ORD-2026-1003"
		}
		order, err := Q.CustomerOrdersMinimal().SelectOrderNote().WithOrderNumberIs(number).Limit(2).
			Comment("Select nullable order note").Purpose("Verify loaded note and null-only default").ExecuteForOne(context)
		check(err)
		e := customer_order.NewCustomerOrderExpression(order)
		fallback := "No note"
		report(phase, object{"value": nullable(e.OrderNote().Eval()), "fallback": e.OrderNote().OrElse(&fallback)})
	// scenario: note-not-loaded
	case "note-not-loaded":
		order, err := Q.CustomerOrdersMinimal().SelectOrderNumber().WithOrderNumberIs("ORD-2026-1001").Limit(2).
			Comment("Omit order note from projection").Purpose("Expose missing-field errors").ExecuteForOne(context)
		check(err)
		e := customer_order.NewCustomerOrderExpression(order)
		fallback := "No note"
		report(phase, object{"eval": missing(func() { e.OrderNote().Eval() }), "fallback": missing(func() { e.OrderNote().OrElse(&fallback) })})
	// scenario: invalid-quantity
	case "invalid-quantity":
		results := []object{}
		for _, quantity := range []float64{0, -1, 1.5, 101} {
			err := edit(context, quantity, false)
			if err == nil || err.Error() != "Quantity must be an integer in [1, 100]" {
				panic("Wrong validation outcome")
			}
			results = append(results, object{"quantity": quantity, "rejected": true, "reason": err.Error()})
		}
		report(phase, results)
	// scenario: draft-edit
	case "draft-edit":
		check(edit(context, 3, false))
		report(phase, graph(context))
	case "rollback-probe":
		err := edit(context, 3, true)
		if err == nil {
			panic("Stale child accepted")
		}
		report(phase, object{"rejected": true, "reason": err.Error()})
	default:
		panic("Unknown phase")
	}
	fmt.Println("ORDER_OK phase=" + phase)
}
