package main
import(stdcontext "context";"database/sql";"encoding/json";"errors";"fmt";"os";"path/filepath";"strings";"time";goruntime "runtime";"runtime/pprof";"github.com/teaql/teaql-golang/data_service";"github.com/teaql/teaql-golang/runtime";. "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")
type object=map[string]any
const seedReason="Seed stock reservation fixture"
const reason="Stress Order and item atomically"
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 seed(context *runtime.UserContext) {
	b, e := os.ReadFile(os.Getenv("ORDER_FIXTURE"))
	check(e)
	var f struct {
		Tenants []struct {
			Key       string
			Available int64
		}
		Buyers []string
		Orders []struct {
			Number   string
			Quantity int64
		}
		Sku              string
		ControlSku       string
		ControlAvailable int64
		UnitPriceMinor   int64
	}
	check(json.Unmarshal(b, &f))
	roots, e := Q.CommercePlatforms().Limit(2).Comment("Read initialized stock root").Purpose(seedReason).ExecuteForList(context)
	check(e)
	if len(roots.Data) != 1 {
		panic("Expected initialized root")
	}
	for n, t := range f.Tenants {
		root := roots.Data[0]
		if n != 0 {
			root = Q.CommercePlatforms().Comment("Create tenant").Purpose(seedReason).NewEntity(context)
		}
		root.UpdateName("Tenant " + t.Key[len(t.Key)-1:])
		root.UpdateTenantKey(t.Key)
		root.UpdateReservationSequence(0)
		_, e = root.AuditAs(seedReason).Save(context)
		check(e)
		rid := required(commerce_platform.NewCommercePlatformExpression(root).Id().Eval())
		for k := 0; k < 2; k++ {
			sku, qty := f.Sku, t.Available
			if k == 1 {
				sku, qty = f.ControlSku, f.ControlAvailable
			}
			stock := Q.Inventory().Comment("Create SKU inventory").Purpose(seedReason).NewEntity(context)
			stock.UpdateCommercePlatformId(rid)
			stock.UpdateSkuCode(sku)
			stock.UpdateAvailableQuantity(qty)
			stock.UpdateReservedQuantity(0)
			stock.UpdateWarehouseNote("Initial warehouse stock")
			_, e = stock.AuditAs(seedReason).Save(context)
			check(e)
		}
		for _, buyer := range f.Buyers {
			for _, d := range f.Orders {
				o := Q.CustomerOrders().Comment("Create stock Order").Purpose(seedReason).NewEntity(context)
				o.UpdateCommercePlatformId(rid)
				o.UpdateOrderStatusId(1001)
				o.UpdateOrderNumber(d.Number)
				o.UpdateBuyerReference(buyer)
				o.UpdateCurrencyCode("USD")
				o.UpdateTotalMinor(d.Quantity * f.UnitPriceMinor)
				note := "Stock reservation fixture order"
				o.UpdateOrderNote(note)
				_, e = o.AuditAs(seedReason).Save(context)
				check(e)
				i := Q.OrderItems().Comment("Create complete Order line").Purpose(seedReason).NewEntity(context)
				i.UpdateCustomerOrderId(required(customer_order.NewCustomerOrderExpression(o).Id().Eval()))
				i.UpdateSkuCode(f.Sku)
				i.UpdateProductName(f.Sku)
				i.UpdateQuantity(d.Quantity)
				i.UpdateUnitPriceMinor(f.UnitPriceMinor)
				i.UpdateLineTotalMinor(d.Quantity * f.UnitPriceMinor)
				_, e = i.AuditAs(seedReason).Save(context)
				check(e)
			}
		}
	}
}


type FaultGate struct{mode,folder string;calibrate bool;db *sql.DB;active,started,finished,transactions int}
func(g *FaultGate)publish(name string,value any){b,e:=json.Marshal(value);check(e);tmp:=filepath.Join(g.folder,name+".tmp");check(os.WriteFile(tmp,b,0600));check(os.Rename(tmp,filepath.Join(g.folder,name+".json")))}
func(g *FaultGate)wait(name string){end:=time.Now().Add(90*time.Second);for{if _,e:=os.Stat(filepath.Join(g.folder,name));e==nil{return};if time.Now().After(end){panic("Stress protocol timeout "+name)};time.Sleep(2*time.Millisecond)}}
func(g *FaultGate)metrics()object{time.Sleep(5*time.Millisecond);if goruntime.NumGoroutine()>4{pprof.Lookup("goroutine").WriteTo(os.Stdout,2)};stats:=g.db.Stats();dir,e:=os.Open("/dev/fd");check(e);fds,e:=dir.Readdirnames(-1);check(e);check(dir.Close());return object{"activeTransactions":g.transactions,"activeTasks":g.active,"startedTasks":g.started,"finishedTasks":g.finished,"openConnections":stats.OpenConnections,"leasedConnections":stats.InUse,"idleConnections":stats.Idle,"poolWaitCount":stats.WaitCount,"goroutines":goruntime.NumGoroutine(),"quiescenceDelayMs":5,"fd":len(fds)}}
func(g *FaultGate)event(event string,detail object){}
func(g *FaultGate)gate(point string,cancel stdcontext.CancelFunc)error{if point=="after-inventory"&&g.mode=="cancel"{if g.calibrate{g.publish("held",g.metrics());g.wait("held-release")};cancel();return stdcontext.Canceled};return nil}
type ObservedProvider struct {
	data_service.QueryExecutor
	mutation    data_service.MutationExecutor
	transaction data_service.TransactionExecutor
	g           *FaultGate
	original    any
}

func (p *ObservedProvider) Mutate(ctx stdcontext.Context, r data_service.MutationRequest) (*data_service.MutationResult, error) {
	return p.mutation.Mutate(ctx, r)
}
func (p *ObservedProvider) Begin(ctx stdcontext.Context) (data_service.Transaction, error) {
	request, cancel := stdcontext.WithCancel(ctx)
	tx, e := p.transaction.Begin(request)
	if e != nil {
		cancel()
		return nil, e
	}
	p.g.transactions++
	return &ObservedTransaction{Transaction: tx, g: p.g, request: request, cancel: cancel}, nil
}
func (p *ObservedProvider) NextId(ctx stdcontext.Context, entity string) (uint64, error) {
	return p.original.(data_service.IdGeneratorExecutor).NextId(ctx, entity)
}
func (p *ObservedProvider) GenerateId(entity string) (uint64, error) {
	return p.NextId(stdcontext.Background(), entity)
}
func (p *ObservedProvider) EnsureIdFloor(ctx stdcontext.Context, entity string, floor uint64) error {
	return p.original.(interface {
		EnsureIdFloor(stdcontext.Context, string, uint64) error
	}).EnsureIdFloor(ctx, entity, floor)
}

type ObservedTransaction struct {
	data_service.Transaction
	g       *FaultGate
	request stdcontext.Context
	cancel  stdcontext.CancelFunc
 done bool
}

func (t *ObservedTransaction) Mutate(ctx stdcontext.Context, r data_service.MutationRequest) (*data_service.MutationResult, error) {
	result, e := t.Transaction.Mutate(t.request, r)
	if e == nil && strings.Contains(result.Metadata.ParameterizedSQL, "UPDATE customer_order_data") {
		e = t.g.gate("after-inventory", t.cancel)
	}
	return result, e
}
func (t *ObservedTransaction) Query(ctx stdcontext.Context, r *data_service.QueryRequest) (*data_service.QueryResult, error) {
	return t.Transaction.Query(t.request, r)
}
func (t *ObservedTransaction) Commit(ctx stdcontext.Context) error {
	if e := t.g.gate("before-commit", t.cancel); e != nil {
		return e
	}
	t.g.event("COMMIT_START", nil)
	e := t.Transaction.Commit(ctx)
	if e == nil {
		t.finish()
		t.cancel()
	} else {
		t.g.event("COMMIT_ERROR", object{"error": e.Error()})
	}
	return e
}
func (t *ObservedTransaction) Rollback(ctx stdcontext.Context) error {
	t.g.event("ROLLBACK_START", nil)
	e := t.Transaction.Rollback(ctx)
	// database/sql may win the cancellation rollback race. Preserve its native error,
	// while treating its explicit terminal state as ended for the observer.
	if e != nil && t.request.Err() == stdcontext.Canceled && errors.Is(e, sql.ErrTxDone) { t.finish() }
	t.cancel()
	if e == nil {
		t.finish()
	} else {
		t.g.event("ROLLBACK_ERROR", object{"error": e.Error()})
	}
	return e
}
func (t *ObservedTransaction) GenerateId(entity string) (uint64, error) {
	return t.Transaction.(interface{ GenerateId(string) (uint64, error) }).GenerateId(entity)
}
func (t *ObservedTransaction) EnsureIdFloor(ctx stdcontext.Context, entity string, floor uint64) error {
	return t.Transaction.(interface {
		EnsureIdFloor(stdcontext.Context, string, uint64) error
	}).EnsureIdFloor(ctx, entity, floor)
}

func(t *ObservedTransaction)finish(){if !t.done{t.done=true;t.g.transactions--}}
func edit(context *runtime.UserContext,g *FaultGate,r object)(result object){result=object{};defer func(){if failure:=recover();failure!=nil{err,ok:=failure.(error);if !ok{err=fmt.Errorf("%v",failure)};text:=err.Error();lower:=strings.ToLower(text);code:="ERROR";if strings.Contains(lower,"context canceled"){code="CANCELLED"}else if strings.Contains(text,"ORDER_STRESS_PROVIDER_ABORT"){code="PROVIDER_FAILED"}else if !strings.Contains(lower,"busy")&&!strings.Contains(lower,"locked")&&!strings.Contains(lower,"timeout")&&(strings.Contains(lower,"version")||strings.Contains(lower,"optimistic")||strings.Contains(lower,"conflict")||strings.Contains(lower,"stale")||strings.Contains(lower,"authoritative persisted state")){code="CONFLICT"};result["outcome"]=code;result["error"]=text;result["type"]=fmt.Sprintf("%T",err)}}()
 roots,e:=Q.CommercePlatforms().WithTenantKeyIs("TENANT-A").Limit(2).Comment("Resolve trusted stress tenant").Purpose(reason).ExecuteForList(context);check(e);if len(roots.Data)!=1{panic("Invalid root")};rid:=required(commerce_platform.NewCommercePlatformExpression(roots.Data[0]).Id().Eval())
 orders,e:=Q.CustomerOrders().WithCommercePlatformIs(rid).WithBuyerReferenceIs(r["buyer"].(string)).WithOrderNumberIs(r["orderNumber"].(string)).SelectOrderItemListWith(Q.OrderItems().Limit(2)).Limit(2).Comment("Load complete bounded Order and item").Purpose(reason).ExecuteForList(context);check(e);if len(orders.Data)!=1{panic("Invalid Order")};o:=orders.Data[0];items:=o.OrderItemList().Items();if len(items)!=1{panic("Invalid item")};i:=items[0]
 result["originalOrderVersion"]=required(customer_order.NewCustomerOrderExpression(o).Version().Eval());result["originalItemVersion"]=required(order_item.NewOrderItemExpression(i).Version().Eval())
 if r["cohort"]==true{g.publish("preloaded",result);g.wait("cohort-release")};o.UpdateOrderNote(r["token"].(string));i.UpdateProductName(r["token"].(string));_,e=o.AuditAs(reason).Save(context);check(e);result["outcome"]="COMMITTED";return
}
func worker(context *runtime.UserContext,g *FaultGate){g.publish("ready",object{"pid":os.Getpid(),"providerIdentity":fmt.Sprintf("%p",context.GetResource("dataService"))});for n:=0;;n++{g.wait(fmt.Sprintf("%d.command.json",n));b,e:=os.ReadFile(filepath.Join(g.folder,fmt.Sprintf("%d.command.json",n)));check(e);var r object;check(json.Unmarshal(b,&r));result:=object{};if r["action"]=="edit"{g.mode=r["mode"].(string);g.calibrate=r["calibrate"]==true;g.active++;g.started++;done:=make(chan object);go func(){done<-edit(context,g,r)}();result=<-done;g.active--;g.finished++};closed:=r["action"]=="close";if closed{check(g.db.Close())};result["pid"]=os.Getpid();result["metrics"]=g.metrics();result["closed"]=closed;g.publish(fmt.Sprintf("%d.result",n),result);if closed{return}}}
func main(){phase:=os.Args[1];context,e:=ServiceRuntimeFromEnv();check(e);db:=context.GetResource("db").(*sql.DB);db.SetMaxOpenConns(1);db.SetMaxIdleConns(1);defer db.Close();g:=&FaultGate{folder:os.Getenv("ORDER_STRESS_FOLDER"),db:db};if phase=="stress"{provider:=context.GetResource("dataService");context.InsertResource("dataService",&ObservedProvider{QueryExecutor:provider.(data_service.QueryExecutor),mutation:provider.(data_service.MutationExecutor),transaction:provider.(data_service.TransactionExecutor),g:g,original:provider})};if phase=="bootstrap"||phase=="seed"{check(EnsureSchema(context))};switch phase{case "seed":seed(context);case "stress":worker(context,g);case "bootstrap":default:panic("Unknown phase")};fmt.Println("ORDER_OK phase="+phase)}
