package main

import (
	"encoding/json"
	"fmt"
	"github.com/teaql/teaql-golang/runtime"
	"math"
	. "order-workflow-service-core-workspace/lib"
	"order-workflow-service-core-workspace/lib/commerce_platform"
	"order-workflow-service-core-workspace/lib/customer_order"
	"order-workflow-service-core-workspace/lib/order_item"
	"os"
)

type object = map[string]any

const seedReason = "Seed isolated tenant Order fixture"
const noteReason = "Edit own tenant and buyer Order note"
const itemReason = "Edit own tenant and buyer Order item label"

var trusted = map[string][3]string{"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"}}

func check(e error) {
	if e != nil {
		panic(e)
	}
}
func required[T any](v T, ok bool) T {
	if !ok {
		panic("Missing loaded value")
	}
	return v
}
func has(r object, k string) bool { _, ok := r[k]; return ok }
func integer(v any) (int64, bool) {
	f, ok := v.(float64)
	return int64(f), ok && !math.IsNaN(f) && !math.IsInf(f, 0) && math.Trunc(f) == f && f <= 9007199254740991
}
func contains(values []string, v string) bool {
	for _, x := range values {
		if x == v {
			return true
		}
	}
	return false
}
func validate(token string, r object) (int, string) {
	if _, ok := trusted[token]; !ok {
		return 0, "UNAUTHENTICATED"
	}
	for _, k := range []string{"tenant", "buyer", "actor", "permissions", "policy", "userContext"} {
		if has(r, k) {
			return 0, "FORGED_SCOPE"
		}
	}
	op, _ := r["op"].(string)
	if !contains([]string{"list", "detail", "items", "summary", "retained", "edit-note", "edit-item"}, op) {
		return 0, "INVALID_REQUEST"
	}
	for k := range r {
		if !contains([]string{"op", "orderId", "orderNumber", "itemId", "limit", "patch"}, k) {
			return 0, "INVALID_REQUEST"
		}
	}
	limit := int64(2)
	if has(r, "limit") {
		var ok bool
		limit, ok = integer(r["limit"])
		if !ok || limit < 1 || limit > 2 {
			return 0, "INVALID_BOUNDS"
		}
	}
	for _, k := range []string{"orderId", "itemId"} {
		if has(r, k) {
			v, ok := integer(r[k])
			if !ok || v <= 0 {
				return 0, "INVALID_REQUEST"
			}
		}
	}
	if contains([]string{"detail", "items", "edit-note", "edit-item"}, op) && !has(r, "orderId") {
		if _, ok := r["orderNumber"].(string); !ok {
			return 0, "INVALID_REQUEST"
		}
	}
	if contains([]string{"items", "edit-item"}, op) && !has(r, "itemId") {
		return 0, "INVALID_REQUEST"
	}
	if contains([]string{"edit-note", "edit-item"}, op) {
		if token == "readonly" {
			return 0, "FORBIDDEN_OPERATION"
		}
		field := "orderNote"
		if op == "edit-item" {
			field = "productName"
		}
		patch, ok := r["patch"].(map[string]any)
		if !ok || len(patch) != 1 {
			return 0, "FORBIDDEN_FIELD"
		}
		value, ok := patch[field].(string)
		if !ok || len(value) < 1 || len(value) > 80 {
			return 0, "FORBIDDEN_FIELD"
		}
	} else if has(r, "patch") {
		return 0, "FORBIDDEN_FIELD"
	}
	return int(limit), ""
}
func row(o *customer_order.CustomerOrder, children bool) object {
	e := customer_order.NewCustomerOrderExpression(o)
	items := []object{}
	if children {
		for _, i := range o.OrderItemList().Items() {
			v := order_item.NewOrderItemExpression(i)
			items = append(items, object{"id": required(v.Id().Eval()), "sku": required(v.SkuCode().Eval()), "productName": required(v.ProductName().Eval()), "version": required(v.Version().Eval())})
		}
	}
	result := object{"id": required(e.Id().Eval()), "buyer": required(e.BuyerReference().Eval()), "orderNumber": required(e.OrderNumber().Eval()), "note": required(e.OrderNote().Eval()), "totalMinor": required(e.TotalMinor().Eval()), "version": required(e.Version().Eval())}
	if children {
		result["items"] = items
	}
	return result
}
func handle(context *runtime.UserContext, token string, r object) object {
	limit, code := validate(token, r)
	if code != "" {
		return object{"code": code}
	}
	s := trusted[token]
	actor, tenant, buyer := s[0], s[1], s[2]
	op := r["op"].(string)
	roots, err := Q.CommercePlatforms().WithTenantKeyIs(tenant).Limit(2).Comment("Resolve tenant from trusted server session").Purpose("Bind the authorized Order scope").ExecuteForList(context)
	check(err)
	if len(roots.Data) != 1 {
		return object{"code": "INVALID_TRUSTED_SCOPE"}
	}
	root := required(commerce_platform.NewCommercePlatformExpression(roots.Data[0]).Id().Eval())
	if op == "summary" {
		values, err := Q.CustomerOrders().WithCommercePlatformIs(root).WithBuyerReferenceIs(buyer).CountAs("count").SumTotalMinorAs("amount").Limit(1).Comment("Summarize only authorized Orders").Purpose("Enforce tenant and buyer scope on aggregates").ExecuteRecords(context)
		check(err)
		return object{"code": "OK", "actor": actor, "tenant": tenant, "buyer": buyer, "count": required(values[0]["count"].TryU64()), "amount": required(values[0]["amount"].TryF64())}
	}
	q := Q.CustomerOrders().WithCommercePlatformIs(root).WithBuyerReferenceIs(buyer).OrderByIdAsc()
	if op != "retained" {
		q = q.SelectOrderItemListWith(Q.OrderItems().OrderByIdAsc().Limit(3))
	}
	if has(r, "orderId") {
		id, _ := integer(r["orderId"])
		q = q.WithIdIs(uint64(id))
	}
	if has(r, "orderNumber") {
		q = q.WithOrderNumberIs(r["orderNumber"].(string))
	}
	if op == "retained" {
		q = q.OptimizePaginationWithIDSetConfig("order-isolation-shared", 300, 20)
	}
	page, err := q.Limit(uint64(limit)).Comment("Load authorized Orders and bounded owned items").Purpose("Apply trusted tenant and buyer predicates before provider access").ExecuteForPage(context, 0, uint64(limit))
	check(err)
	if op == "list" || op == "retained" {
		rows := []object{}
		for _, o := range page.Data {
			rows = append(rows, row(o, op != "retained"))
		}
		result := object{"code": "OK", "actor": actor, "tenant": tenant, "buyer": buyer, "rows": rows, "total": *page.TotalCount}
		if op == "retained" {
			result["plan"] = context.IDSetPlan()
		}
		return result
	}
	if len(page.Data) != 1 {
		return object{"code": "NOT_FOUND"}
	}
	o := page.Data[0]
	items := o.OrderItemList().Items()
	if len(items) > 2 {
		return object{"code": "ITEM_LIMIT"}
	}
	var selected *order_item.OrderItem
	if has(r, "itemId") {
		id, _ := integer(r["itemId"])
		for _, i := range items {
			if required(order_item.NewOrderItemExpression(i).Id().Eval()) == uint64(id) {
				selected = i
			}
		}
	}
	if (op == "items" || op == "edit-item") && selected == nil {
		return object{"code": "NOT_FOUND"}
	}
	if op == "edit-note" {
		o, err = Q.CustomerOrders().WithCommercePlatformIs(root).WithBuyerReferenceIs(buyer).WithIdIs(required(customer_order.NewCustomerOrderExpression(o).Id().Eval())).Limit(2).Comment("Reload authorized complete Order scalars").Purpose("Save one authorized note without touching item graphs").ExecuteForOne(context)
		check(err)
		if o == nil {
			return object{"code": "NOT_FOUND"}
		}
		value := r["patch"].(map[string]any)["orderNote"].(string)
		o.UpdateOrderNote(&value)
		_, err := o.AuditAs(noteReason).Save(context)
		check(err)
		return object{"code": "OK", "changed": true}
	}
	if op == "edit-item" {
		selected.UpdateProductName(r["patch"].(map[string]any)["productName"].(string))
		_, err := selected.AuditAs(itemReason).Save(context)
		check(err)
		return object{"code": "OK", "changed": true}
	}
	value := row(o, op != "retained")
	if op == "items" {
		v := order_item.NewOrderItemExpression(selected)
		value["items"] = []object{{"id": required(v.Id().Eval()), "sku": required(v.SkuCode().Eval()), "productName": required(v.ProductName().Eval()), "version": required(v.Version().Eval())}}
	}
	return object{"code": "OK", "actor": actor, "tenant": tenant, "buyer": buyer, "rows": []object{value}, "total": *page.TotalCount}
}
func seed(context *runtime.UserContext) {
	roots, err := Q.CommercePlatforms().Limit(2).Comment("Read initialized tenant root").Purpose("Seed isolated Order fixture").ExecuteForList(context)
	check(err)
	if len(roots.Data) != 1 {
		panic("Expected initialized root")
	}
	for n, tenant := range []string{"TENANT-A", "TENANT-B"} {
		root := roots.Data[0]
		if n == 1 {
			root = Q.CommercePlatforms().Comment("Create tenant root").Purpose("Seed isolated Order fixture").NewEntity(context)
		}
		root.UpdateName("Tenant " + tenant[len(tenant)-1:])
		root.UpdateTenantKey(tenant)
		saved, err := root.AuditAs(seedReason).Save(context)
		check(err)
		rootID := required(commerce_platform.NewCommercePlatformExpression(saved).Id().Eval())
		for _, buyer := range []string{"BUYER-A", "BUYER-B"} {
			for _, number := range []string{"ORD-SHARED-001", "ORD-SHARED-002"} {
				o := Q.CustomerOrders().Comment("Create tenant-owned Order").Purpose("Seed isolated Order fixture").NewEntity(context)
				o.UpdateCommercePlatformId(rootID)
				o.UpdateOrderStatusId(1001)
				o.UpdateOrderNumber(number)
				o.UpdateBuyerReference(buyer)
				o.UpdateCurrencyCode("USD")
				o.UpdateTotalMinor(3850)
				note := "Original " + tenant + " " + buyer
				o.UpdateOrderNote(&note)
				persisted, err := o.AuditAs(seedReason).Save(context)
				check(err)
				id := required(customer_order.NewCustomerOrderExpression(persisted).Id().Eval())
				for k := 0; k < 2; k++ {
					i := Q.OrderItems().Comment("Create owned Order line").Purpose("Seed isolated Order fixture").NewEntity(context)
					i.UpdateCustomerOrderId(id)
					sku, quantity, price, total := "SKU-NOTEBOOK", int64(2), int64(1250), int64(2500)
					if k == 1 {
						sku, quantity, price, total = "SKU-PEN", 3, 450, 1350
					}
					i.UpdateSkuCode(sku)
					i.UpdateProductName(sku)
					i.UpdateQuantity(quantity)
					i.UpdateUnitPriceMinor(price)
					i.UpdateLineTotalMinor(total)
					_, err := i.AuditAs(seedReason).Save(context)
					check(err)
				}
			}
		}
	}
}
func printResult(value object) {
	b, err := json.Marshal(value)
	check(err)
	fmt.Println("ORDER_ISOLATION_RESULT " + string(b))
}
func main() {
	phase := os.Args[1]
	context, err := ServiceRuntimeFromEnv()
	check(err)
	context.SetIDSetStore(runtime.NewInMemoryIDSetStore())
	if phase == "bootstrap" || phase == "seed" {
		check(EnsureSchema(context))
	}
	switch phase {
	case "seed":
		seed(context)
	case "request":
		b, err := os.ReadFile(os.Getenv("ORDER_REQUEST"))
		check(err)
		var request object
		check(json.Unmarshal(b, &request))
		fmt.Println("ORDER_ISOLATION_BEGIN")
		printResult(handle(context, os.Getenv("ORDER_SESSION"), request))
	case "cache":
		fmt.Println("ORDER_ISOLATION_BEGIN")
		pages := []object{}
		for _, token := range []string{"a", "b", "c", "a"} {
			pages = append(pages, handle(context, token, object{"op": "retained", "limit": float64(1)}))
		}
		printResult(object{"pages": pages})
	case "bootstrap":
	default:
		panic("Unknown phase")
	}
	fmt.Println("ORDER_OK phase=" + phase)
}
