package mapping

import (
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"reflect"
	"strings"
	"testing"
	"time"

	commonsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/commonv1"
	semantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/layoutauthoringv1"
	"github.com/pingcap-inc/nexuscrm-contract/wire-go/envelope"
	runtimev1 "github.com/pingcap-inc/nexuscrm-contract/wire-go/gen/runtime/v1"
	"google.golang.org/protobuf/encoding/protowire"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/reflect/protoreflect"
)

func TestLayoutAuthoringWireRoundTripsAllOperations(t *testing.T) {
	profileID := "profile-a"
	operations := map[string]semantic.CommandOperation{
		"create": {Create: &semantic.CreateLayout{
			Document:                 layoutAuthoringTestDocument(),
			ListFields:               semantic.FieldIDListChange{Mode: semantic.ChangeSet, Value: layoutAuthoringPointer([]string{"Name", "OwnerId"})},
			ExpectedWorkspaceVersion: layoutAuthoringPointer("workspace-v1"),
		}},
		"update": {Update: &semantic.UpdateLayout{
			LayoutID: "layout-main", ExpectedAggregateVersion: "aggregate-v1",
			Changes: layoutAuthoringTestChanges(), ListFields: semantic.FieldIDListChange{Mode: semantic.ChangeClear},
		}},
		"clone": {Clone: &semantic.CloneLayout{
			SourceLayoutID: "layout-main", SourceResourceVersion: "resource-v1", TargetLayoutID: "layout-copy",
			TargetName: "Copy", ExpectedWorkspaceVersion: "workspace-v1",
		}},
		"set default": {SetDefault: &semantic.SetDefaultLayout{ObjectID: "Account", LayoutID: "layout-main", ExpectedWorkspaceVersion: "workspace-v1"}},
		"delete":      {Delete: &semantic.DeleteLayout{LayoutID: "layout-main", ExpectedResourceVersion: "resource-v1", ExpectedWorkspaceVersion: "workspace-v1"}},
		"restore":     {Restore: &semantic.RestoreLayout{LayoutID: "layout-main", HistoryVersion: 7, ExpectedResourceVersion: "resource-v1"}},
		"assignment upsert": {AssignmentUpsert: &semantic.UpsertLayoutAssignment{
			ObjectID: "Account", LayoutID: "layout-main", Selectors: semantic.AssignmentSelectors{ProfileID: &profileID}, ExpectedWorkspaceVersion: "workspace-v1",
		}},
		"assignment delete": {AssignmentDelete: &semantic.DeleteLayoutAssignment{AssignmentID: "assignment-a", ExpectedResourceVersion: "resource-v1", ExpectedWorkspaceVersion: "workspace-v1"}},
	}

	for name, operation := range operations {
		t.Run(name, func(t *testing.T) {
			request := layoutAuthoringTestSubmit(operation)
			wire, err := ToWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), request)
			if err != nil {
				t.Fatalf("to wire = %v", err)
			}
			encoded, err := proto.Marshal(wire)
			if err != nil {
				t.Fatal(err)
			}
			if len(encoded) >= envelope.MaxRequestWireBytes {
				t.Fatalf("wire request bytes = %d", len(encoded))
			}
			if err := PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); err != nil {
				t.Fatalf("preflight = %v", err)
			}
			var decoded runtimev1.LayoutAuthoringServiceSubmitRequest
			if err := proto.Unmarshal(encoded, &decoded); err != nil {
				t.Fatal(err)
			}
			roundTrip, err := FromWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), &decoded)
			if err != nil || !reflect.DeepEqual(roundTrip, request) {
				t.Fatalf("round trip = %#v, %v\nwant = %#v", roundTrip, err, request)
			}
		})
	}
}

func TestLayoutAuthoringCommandFailureWireIsClosed(t *testing.T) {
	request := layoutAuthoringTestSubmit(semantic.CommandOperation{
		SetDefault: &semantic.SetDefaultLayout{ObjectID: "Account", LayoutID: "layout-main", ExpectedWorkspaceVersion: "workspace-v1"},
	})
	digest, err := semantic.RequestDigest(request)
	if err != nil {
		t.Fatal(err)
	}
	getRequest := semantic.GetCommandRequest{CommandID: request.CommandID, RequestDigest: digest}
	for _, category := range semantic.AllCommandFailureCategories() {
		status := semantic.CommandStatus{
			CommandID: request.CommandID, RequestDigest: digest, State: semantic.StateFailed,
			Failure:  &semantic.CommandFailure{Category: category, Message: "layout command rejected", FieldReference: "/set_default/layout_id"},
			Receipts: layoutAuthoringTestReceipts(50),
		}
		wire, err := ToWireLayoutAuthoringCommandStatus(getRequest, status)
		if err != nil {
			t.Fatalf("%s to wire = %v", category, err)
		}
		roundTrip, err := FromWireLayoutAuthoringCommandStatus(getRequest, wire)
		if err != nil || !reflect.DeepEqual(roundTrip, status) {
			t.Fatalf("%s round trip = %#v, %v; want %#v", category, roundTrip, err, status)
		}
	}

	if got := len(runtimev1.LayoutAuthoringCommandFailureCategory_name); got != 5 {
		t.Fatalf("wire failure category count = %d, want unspecified plus four public categories", got)
	}
	for _, category := range []runtimev1.LayoutAuthoringCommandFailureCategory{
		runtimev1.LayoutAuthoringCommandFailureCategory_LAYOUT_AUTHORING_COMMAND_FAILURE_CATEGORY_UNSPECIFIED,
		runtimev1.LayoutAuthoringCommandFailureCategory(1000),
	} {
		wire := &runtimev1.LayoutAuthoringServiceGetCommandResponse{
			CommandId: request.CommandID, RequestDigest: digest,
			State:    runtimev1.LayoutAuthoringCommandState_LAYOUT_AUTHORING_COMMAND_STATE_FAILED,
			Failure:  &runtimev1.LayoutAuthoringCommandFailure{Category: category, Message: "layout command rejected"},
			Receipts: toWireReceipts(layoutAuthoringTestReceipts(50), layoutAuthoringCapability),
		}
		if _, err := FromWireLayoutAuthoringCommandStatus(getRequest, wire); err == nil {
			t.Fatalf("non-Layout failure category %v was accepted", category)
		}
	}
}

func TestLayoutAuthoringWirePreservesAllResultsAndPublicStates(t *testing.T) {
	document := layoutAuthoringTestDocument()
	profileID := "profile-a"
	operationsAndResults := map[string]struct {
		operation semantic.CommandOperation
		result    semantic.CommandResult
	}{
		"create": {
			operation: semantic.CommandOperation{Create: &semantic.CreateLayout{Document: document, ListFields: semantic.FieldIDListChange{Mode: semantic.ChangeSet, Value: layoutAuthoringPointer([]string{"Name", "OwnerId"})}, ExpectedWorkspaceVersion: layoutAuthoringPointer("workspace-v1")}},
			result:    semantic.CommandResult{Create: &semantic.CreateLayoutResult{Layout: layoutAuthoringTestSnapshot(document, []string{"Name", "OwnerId"})}},
		},
		"update": {
			operation: semantic.CommandOperation{Update: &semantic.UpdateLayout{LayoutID: "layout-main", ExpectedAggregateVersion: "aggregate-v1", Changes: layoutAuthoringTestChanges(), ListFields: semantic.FieldIDListChange{Mode: semantic.ChangeClear}}},
			result:    semantic.CommandResult{Update: &semantic.UpdateLayoutResult{Layout: layoutAuthoringTestSnapshot(layoutAuthoringUpdatedDocument(document), []string{})}},
		},
		"clone": {
			operation: semantic.CommandOperation{Clone: &semantic.CloneLayout{SourceLayoutID: "layout-main", SourceResourceVersion: "resource-v1", TargetLayoutID: "layout-copy", TargetName: "Copy", ExpectedWorkspaceVersion: "workspace-v1"}},
			result:    semantic.CommandResult{Clone: &semantic.CloneLayoutResult{Layout: layoutAuthoringTestSnapshot(layoutAuthoringCloneDocument(document), []string{"Name", "OwnerId"})}},
		},
		"set default": {
			operation: semantic.CommandOperation{SetDefault: &semantic.SetDefaultLayout{ObjectID: "Account", LayoutID: "layout-main", ExpectedWorkspaceVersion: "workspace-v1"}},
			result:    semantic.CommandResult{SetDefault: &semantic.SetDefaultLayoutResult{ObjectID: "Account", LayoutID: "layout-main", WorkspaceVersion: "workspace-v2"}},
		},
		"delete": {
			operation: semantic.CommandOperation{Delete: &semantic.DeleteLayout{LayoutID: "layout-main", ExpectedResourceVersion: "resource-v1", ExpectedWorkspaceVersion: "workspace-v1"}},
			result:    semantic.CommandResult{Delete: &semantic.DeleteLayoutResult{LayoutID: "layout-main", ObjectID: "Account", WorkspaceVersion: "workspace-v2"}},
		},
		"restore": {
			operation: semantic.CommandOperation{Restore: &semantic.RestoreLayout{LayoutID: "layout-main", HistoryVersion: 7, ExpectedResourceVersion: "resource-v1"}},
			result:    semantic.CommandResult{Restore: &semantic.RestoreLayoutResult{Layout: layoutAuthoringTestSnapshot(document, []string{"Name", "OwnerId"}), HistoryVersion: 7}},
		},
		"assignment upsert": {
			operation: semantic.CommandOperation{AssignmentUpsert: &semantic.UpsertLayoutAssignment{ObjectID: "Account", LayoutID: "layout-main", Selectors: semantic.AssignmentSelectors{ProfileID: &profileID}, ExpectedWorkspaceVersion: "workspace-v1"}},
			result:    semantic.CommandResult{AssignmentUpsert: &semantic.UpsertLayoutAssignmentResult{Assignment: semantic.LayoutAssignmentSummary{AssignmentID: "assignment-a", ObjectID: "Account", LayoutID: "layout-main", Selectors: semantic.AssignmentSelectors{ProfileID: &profileID}, Specificity: 1, ResourceVersion: "resource-v2"}, WorkspaceVersion: "workspace-v2"}},
		},
		"assignment delete": {
			operation: semantic.CommandOperation{AssignmentDelete: &semantic.DeleteLayoutAssignment{AssignmentID: "assignment-a", ExpectedResourceVersion: "resource-v1", ExpectedWorkspaceVersion: "workspace-v1"}},
			result:    semantic.CommandResult{AssignmentDelete: &semantic.DeleteLayoutAssignmentResult{AssignmentID: "assignment-a", ObjectID: "Account", WorkspaceVersion: "workspace-v2"}},
		},
	}

	for name, fixture := range operationsAndResults {
		t.Run(name, func(t *testing.T) {
			request := layoutAuthoringTestSubmit(fixture.operation)
			response := semantic.SubmitResponse{Command: layoutAuthoringSucceededStatus(t, request, fixture.result)}
			wire, err := ToWireLayoutAuthoringSubmitResponse(request, response)
			if err != nil {
				t.Fatalf("to wire = %v", err)
			}
			encoded, err := proto.Marshal(wire)
			if err != nil {
				t.Fatal(err)
			}
			if err := PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitResponse{}); err != nil {
				t.Fatalf("preflight = %v", err)
			}
			var decoded runtimev1.LayoutAuthoringServiceSubmitResponse
			if err := proto.Unmarshal(encoded, &decoded); err != nil {
				t.Fatal(err)
			}
			roundTrip, err := FromWireLayoutAuthoringSubmitResponse(request, &decoded)
			if err != nil || !reflect.DeepEqual(roundTrip, response) {
				t.Fatalf("round trip = %#v, %v\nwant = %#v", roundTrip, err, response)
			}
		})
	}

	request := layoutAuthoringTestSubmit(operationsAndResults["set default"].operation)
	digest, err := semantic.RequestDigest(request)
	if err != nil {
		t.Fatal(err)
	}
	getRequest := semantic.GetCommandRequest{CommandID: request.CommandID, RequestDigest: digest}
	statuses := []semantic.CommandStatus{
		{CommandID: request.CommandID, RequestDigest: digest, State: semantic.StateAccepted, Receipts: layoutAuthoringTestReceipts(50)},
		{CommandID: request.CommandID, RequestDigest: digest, State: semantic.StateInProgress, Receipts: layoutAuthoringTestReceipts(50)},
		layoutAuthoringSucceededStatus(t, request, operationsAndResults["set default"].result),
		{CommandID: request.CommandID, RequestDigest: digest, State: semantic.StateFailed, Failure: &semantic.CommandFailure{Category: semantic.FailureConflict, Message: "stale workspace", FieldReference: "/set_default/expected_workspace_version"}, Receipts: layoutAuthoringTestReceipts(50)},
	}
	for _, status := range statuses {
		wire, err := ToWireLayoutAuthoringCommandStatus(getRequest, status)
		if err != nil {
			t.Fatalf("%s to wire = %v", status.State, err)
		}
		roundTrip, err := FromWireLayoutAuthoringCommandStatus(getRequest, wire)
		if err != nil || !reflect.DeepEqual(roundTrip, status) {
			t.Fatalf("%s round trip = %#v, %v", status.State, roundTrip, err)
		}
	}
}

func TestLayoutAuthoringWireRoundTripsExactReads(t *testing.T) {
	viewRef := layoutAuthoringTestViewRef(50)
	workspaceRequest := semantic.WorkspaceRequest{ObjectID: "Account", ViewRef: &viewRef}
	workspace := semantic.Workspace{
		ObjectID: "Account", WorkspaceVersion: "workspace-v2",
		Layouts:     []semantic.LayoutSummary{{LayoutID: "layout-main", ObjectID: "Account", Name: "Main Layout", Kind: "Detail", IsDefault: true, ResourceVersion: "resource-v2"}},
		Assignments: []semantic.LayoutAssignmentSummary{{AssignmentID: "assignment-default", ObjectID: "Account", LayoutID: "layout-main", Selectors: semantic.AssignmentSelectors{}, Specificity: 0, ResourceVersion: "resource-default"}},
		ViewRef:     viewRef, Receipts: layoutAuthoringTestReceipts(50),
	}
	wireWorkspace, err := ToWireLayoutAuthoringWorkspace(workspaceRequest, workspace)
	if err != nil {
		t.Fatal(err)
	}
	roundWorkspace, err := FromWireLayoutAuthoringWorkspace(workspaceRequest, wireWorkspace)
	if err != nil || !reflect.DeepEqual(roundWorkspace, workspace) {
		t.Fatalf("workspace round trip = %#v, %v", roundWorkspace, err)
	}

	storedRequest := semantic.StoredLayoutRequest{LayoutID: "layout-main", ViewRef: &viewRef}
	stored := semantic.StoredLayout{
		Document: layoutAuthoringTestDocument(), OrderedListFields: []string{"Name", "OwnerId"},
		Lifecycle:       semantic.LayoutLifecycleState{ProvenanceKind: "admin"},
		ResourceVersion: "resource-v2", AggregateVersion: "aggregate-v2", WorkspaceVersion: "workspace-v2",
		ViewRef: viewRef, Receipts: layoutAuthoringTestReceipts(50),
	}
	wireStored, err := ToWireLayoutAuthoringStoredLayout(storedRequest, stored)
	if err != nil {
		t.Fatal(err)
	}
	roundStored, err := FromWireLayoutAuthoringStoredLayout(storedRequest, wireStored)
	if err != nil || !reflect.DeepEqual(roundStored, stored) {
		t.Fatalf("stored round trip = %#v, %v", roundStored, err)
	}
}

func TestLayoutAuthoringWirePreflightBoundsNestedAmplification(t *testing.T) {
	behaviors := make([]*runtimev1.LayoutAuthoringFieldBehavior, semantic.MaxFieldBehaviorsPerField+1)
	request := &runtimev1.LayoutAuthoringServiceSubmitRequest{
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document: &runtimev1.LayoutAuthoringDocument{Sections: []*runtimev1.LayoutAuthoringSection{{FieldBehaviors: []*runtimev1.LayoutAuthoringFieldBehaviorGroup{{
				Behaviors: &runtimev1.LayoutAuthoringFieldBehaviorList{Values: behaviors},
			}}}}},
		}},
	}
	encoded, err := proto.Marshal(request)
	if err != nil {
		t.Fatal(err)
	}
	err = PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{})
	var failure *semantic.Failure
	if !errors.As(err, &failure) || failure.Category != semantic.FailureResourceExhausted ||
		failure.LimitKind != semantic.LimitFieldCount || failure.Maximum != semantic.MaxFieldBehaviorsPerField {
		t.Fatalf("behavior amplification = %#v", err)
	}

	groupsRequest := &runtimev1.LayoutAuthoringServiceSubmitRequest{
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document: &runtimev1.LayoutAuthoringDocument{Sections: []*runtimev1.LayoutAuthoringSection{{
				FieldBehaviors: make([]*runtimev1.LayoutAuthoringFieldBehaviorGroup, semantic.MaxFieldBehaviorGroupsPerSection+1),
			}}},
		}},
	}
	groupsBytes, err := proto.Marshal(groupsRequest)
	if err != nil {
		t.Fatal(err)
	}
	err = PreflightPlatformWirePayload(groupsBytes, &runtimev1.LayoutAuthoringServiceSubmitRequest{})
	if !errors.As(err, &failure) || failure.LimitKind != semantic.LimitFieldCount || failure.Maximum != semantic.MaxFieldBehaviorGroupsPerSection {
		t.Fatalf("behavior group amplification = %#v", err)
	}

	compactRequest := &runtimev1.LayoutAuthoringServiceSubmitRequest{
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document: &runtimev1.LayoutAuthoringDocument{CompactFields: make([]string, semantic.MaxCompactFields+1)},
		}},
	}
	compactBytes, err := proto.Marshal(compactRequest)
	if err != nil {
		t.Fatal(err)
	}
	err = PreflightPlatformWirePayload(compactBytes, &runtimev1.LayoutAuthoringServiceSubmitRequest{})
	if !errors.As(err, &failure) || failure.LimitKind != semantic.LimitFieldCount || failure.Maximum != semantic.MaxCompactFields {
		t.Fatalf("compact field limit = %#v", err)
	}

	for _, test := range []struct {
		name    string
		field   func(*runtimev1.LayoutAuthoringDocumentChanges)
		maximum uint64
	}{
		{name: "tabs", maximum: semantic.MaxTabs, field: func(changes *runtimev1.LayoutAuthoringDocumentChanges) {
			changes.Tabs = &runtimev1.LayoutAuthoringStringListChange{Value: &runtimev1.LayoutAuthoringStringList{Values: make([]string, semantic.MaxTabs+1)}}
		}},
		{name: "primary header actions", maximum: semantic.MaxPrimaryHeaderActions, field: func(changes *runtimev1.LayoutAuthoringDocumentChanges) {
			changes.PrimaryHeaderActions = &runtimev1.LayoutAuthoringStringListChange{Value: &runtimev1.LayoutAuthoringStringList{Values: make([]string, semantic.MaxPrimaryHeaderActions+1)}}
		}},
	} {
		t.Run(test.name+" limit ownership", func(t *testing.T) {
			changes := &runtimev1.LayoutAuthoringDocumentChanges{}
			test.field(changes)
			wireRequest := &runtimev1.LayoutAuthoringServiceSubmitRequest{Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Update{Update: &runtimev1.LayoutAuthoringUpdateLayout{Changes: changes}}}
			wireBytes, err := proto.Marshal(wireRequest)
			if err != nil {
				t.Fatal(err)
			}
			err = PreflightPlatformWirePayload(wireBytes, &runtimev1.LayoutAuthoringServiceSubmitRequest{})
			if !errors.As(err, &failure) || failure.LimitKind != semantic.LimitOperationCount || failure.Maximum != test.maximum {
				t.Fatalf("limit = %#v", err)
			}
			decoded := FromPlatformStatusError(ToPlatformStatusError(err, semantic.CapabilityName), semantic.CapabilityName)
			if !errors.As(decoded, &failure) || failure.Category != semantic.FailureResourceExhausted ||
				failure.LimitKind != semantic.LimitOperationCount || failure.Maximum != test.maximum {
				t.Fatalf("status limit = %#v", decoded)
			}
		})
	}

	documentBytes, err := proto.Marshal(&runtimev1.LayoutAuthoringDocument{Sections: make([]*runtimev1.LayoutAuthoringSection, semantic.MaxSections)})
	if err != nil {
		t.Fatal(err)
	}
	createBytes := protowire.AppendTag(nil, 1, protowire.BytesType)
	createBytes = protowire.AppendBytes(createBytes, documentBytes)
	createBytes = protowire.AppendTag(createBytes, 1, protowire.BytesType)
	createBytes = protowire.AppendBytes(createBytes, documentBytes)
	duplicateDocument := protowire.AppendTag(nil, 10, protowire.BytesType)
	duplicateDocument = protowire.AppendBytes(duplicateDocument, createBytes)
	if err := PreflightPlatformWirePayload(duplicateDocument, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); !errors.Is(err, ErrMalformedPlatformWire) {
		t.Fatalf("duplicate singular document = %#v", err)
	}

	stringListBytes, err := proto.Marshal(&runtimev1.LayoutAuthoringStringList{Values: make([]string, semantic.MaxListFields)})
	if err != nil {
		t.Fatal(err)
	}
	duplicateStringListValue := protowire.AppendTag(nil, 2, protowire.BytesType)
	duplicateStringListValue = protowire.AppendBytes(duplicateStringListValue, stringListBytes)
	duplicateStringListValue = protowire.AppendTag(duplicateStringListValue, 2, protowire.BytesType)
	duplicateStringListValue = protowire.AppendBytes(duplicateStringListValue, stringListBytes)
	createWithList := protowire.AppendTag(nil, 2, protowire.BytesType)
	createWithList = protowire.AppendBytes(createWithList, duplicateStringListValue)
	submitWithList := protowire.AppendTag(nil, 10, protowire.BytesType)
	submitWithList = protowire.AppendBytes(submitWithList, createWithList)
	if err := PreflightPlatformWirePayload(submitWithList, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); !errors.Is(err, ErrMalformedPlatformWire) {
		t.Fatalf("duplicate singular string-list value = %#v", err)
	}

	sectionListBytes, err := proto.Marshal(&runtimev1.LayoutAuthoringSectionList{Values: make([]*runtimev1.LayoutAuthoringSection, semantic.MaxSections)})
	if err != nil {
		t.Fatal(err)
	}
	duplicateSectionListValue := protowire.AppendTag(nil, 2, protowire.BytesType)
	duplicateSectionListValue = protowire.AppendBytes(duplicateSectionListValue, sectionListBytes)
	duplicateSectionListValue = protowire.AppendTag(duplicateSectionListValue, 2, protowire.BytesType)
	duplicateSectionListValue = protowire.AppendBytes(duplicateSectionListValue, sectionListBytes)
	changesWithSections := protowire.AppendTag(nil, 6, protowire.BytesType)
	changesWithSections = protowire.AppendBytes(changesWithSections, duplicateSectionListValue)
	updateWithSections := protowire.AppendTag(nil, 3, protowire.BytesType)
	updateWithSections = protowire.AppendBytes(updateWithSections, changesWithSections)
	submitWithSections := protowire.AppendTag(nil, 11, protowire.BytesType)
	submitWithSections = protowire.AppendBytes(submitWithSections, updateWithSections)
	if err := PreflightPlatformWirePayload(submitWithSections, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); !errors.Is(err, ErrMalformedPlatformWire) {
		t.Fatalf("duplicate singular message-list value = %#v", err)
	}

	validWire, err := ToWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), layoutAuthoringTestSubmit(semantic.CommandOperation{
		SetDefault: &semantic.SetDefaultLayout{ObjectID: "Account", LayoutID: "layout-main", ExpectedWorkspaceVersion: "workspace-v1"},
	}))
	if err != nil {
		t.Fatal(err)
	}
	unknown, err := proto.Marshal(validWire)
	if err != nil {
		t.Fatal(err)
	}
	unknown = protowire.AppendTag(unknown, 999, protowire.BytesType)
	unknown = protowire.AppendBytes(unknown, []byte("future"))
	if err := PreflightPlatformWirePayload(unknown, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); err != nil {
		t.Fatalf("unknown additive field rejected by preflight: %v", err)
	}

	oversize := make([]byte, envelope.MaxRequestWireBytes+1)
	if err := PreflightPlatformWirePayload(oversize, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); !errors.As(err, &failure) || failure.LimitKind != commonsemantic.LimitWireFrame {
		t.Fatalf("gross oversize = %#v", err)
	}

	workspace := &runtimev1.LayoutAuthoringServiceReadWorkspaceResponse{
		Layouts: make([]*runtimev1.LayoutAuthoringLayoutSummary, semantic.MaxWorkspaceLayouts+1),
	}
	workspaceBytes, err := proto.Marshal(workspace)
	if err != nil {
		t.Fatal(err)
	}
	if err := PreflightPlatformWirePayload(workspaceBytes, &runtimev1.LayoutAuthoringServiceReadWorkspaceResponse{}); err == nil {
		t.Fatal("oversized workspace collection passed response preflight")
	}
}

func TestLayoutAuthoringPreflightRejectsCrossParentSemanticAmplification(t *testing.T) {
	for name, document := range map[string]*runtimev1.LayoutAuthoringDocument{
		"field labels":       amplifiedLayoutAuthoringFieldLabels(),
		"prefill mappings":   amplifiedLayoutAuthoringPrefillMappings(),
		"record state links": amplifiedLayoutAuthoringRecordStateLinks(),
	} {
		t.Run(name, func(t *testing.T) {
			request := &runtimev1.LayoutAuthoringServiceSubmitRequest{
				CommandId: "command-1", IdempotencyKey: "idempotency-1", BaseCatalogRevision: 41,
				WaitMode: runtimev1.LayoutAuthoringWaitMode_LAYOUT_AUTHORING_WAIT_MODE_WAIT_FOR_TERMINAL,
				Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
					Document: document,
					ListFields: &runtimev1.LayoutAuthoringStringListChange{
						Mode: runtimev1.LayoutAuthoringChangeMode_LAYOUT_AUTHORING_CHANGE_MODE_PRESERVE,
					},
				}},
			}
			encoded, err := proto.Marshal(request)
			if err != nil {
				t.Fatal(err)
			}
			if len(encoded) >= envelope.MaxRequestWireBytes {
				t.Fatalf("amplified fixture is not discriminating: %d wire bytes", len(encoded))
			}

			assertLayoutAuthoringDocumentLimit := func(source string, err error) {
				t.Helper()
				var failure *semantic.Failure
				if !errors.As(err, &failure) || failure.Category != semantic.FailureResourceExhausted ||
					failure.LimitKind != semantic.LimitSemanticRequest || failure.Maximum != semantic.MaxLayoutDocumentSemanticBytes {
					t.Fatalf("%s = %#v, want Layout document semantic limit", source, err)
				}
			}
			assertLayoutAuthoringDocumentLimit("raw preflight", PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{}))
			assertLayoutAuthoringDocumentLimit("typed preflight", preflightWireLayoutAuthoringSubmitRequest(request))
			_, err = FromWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), request)
			assertLayoutAuthoringDocumentLimit("FromWire", err)
		})
	}
}

func TestLayoutAuthoringTypedPreflightRegistersEveryRepeatedWireField(t *testing.T) {
	seenFields := make(map[string]struct{})
	messagesByName := make(map[string]protoreflect.MessageDescriptor)
	messages := runtimev1.File_runtime_v1_layout_authoring_proto.Messages()
	for messageIndex := 0; messageIndex < messages.Len(); messageIndex++ {
		message := messages.Get(messageIndex)
		messagesByName[string(message.FullName())] = message
		fields := message.Fields()
		for fieldIndex := 0; fieldIndex < fields.Len(); fieldIndex++ {
			field := fields.Get(fieldIndex)
			seenFields[string(field.FullName())] = struct{}{}
			if field.Message() != nil && field.Message().FullName() == "nexuscrm.runtime.v1.LayoutAuthoringStringListChange" {
				if _, registered := layoutAuthoringContextualStringListPolicies[field.FullName()]; !registered {
					t.Errorf("Layout string-list use %s has no contextual preflight policy", field.FullName())
				}
			}
			if !field.IsList() {
				continue
			}
			if field.FullName() == layoutAuthoringField("LayoutAuthoringStringList", "values") {
				continue
			}
			if _, registered := layoutAuthoringRepeatedPolicies[field.FullName()]; !registered {
				t.Errorf("repeated Layout wire field %s has no typed preflight policy", field.FullName())
			}
		}
	}
	for field := range layoutAuthoringRepeatedPolicies {
		if _, exists := seenFields[string(field)]; !exists {
			t.Errorf("typed preflight policy references missing field %s", field)
		}
	}
	for field := range layoutAuthoringContextualStringListPolicies {
		if _, exists := seenFields[string(field)]; !exists {
			t.Errorf("contextual string-list policy references missing field %s", field)
		}
	}
	for field := range layoutAuthoringSingularFloors {
		if _, exists := seenFields[string(field)]; !exists {
			t.Errorf("singular semantic floor references missing field %s", field)
		}
	}
	var assertLeaf func(protoreflect.MessageDescriptor, map[protoreflect.FullName]struct{})
	assertLeaf = func(message protoreflect.MessageDescriptor, visiting map[protoreflect.FullName]struct{}) {
		t.Helper()
		if _, cycle := visiting[message.FullName()]; cycle {
			t.Errorf("admission leaf %s contains a recursive message", message.FullName())
			return
		}
		visiting[message.FullName()] = struct{}{}
		defer delete(visiting, message.FullName())
		fields := message.Fields()
		for index := 0; index < fields.Len(); index++ {
			field := fields.Get(index)
			if field.IsList() {
				t.Errorf("admission leaf %s contains repeated field %s", message.FullName(), field.FullName())
			}
			if field.Message() != nil {
				assertLeaf(field.Message(), visiting)
			}
		}
	}
	for name := range layoutAuthoringAdmissionLeafMessages {
		message, exists := messagesByName[string(name)]
		if !exists {
			t.Errorf("admission leaf references missing message %s", name)
			continue
		}
		assertLeaf(message, make(map[protoreflect.FullName]struct{}))
	}
}

func TestLayoutAuthoringResponseMapperPreflightsDecodedCollections(t *testing.T) {
	request := semantic.WorkspaceRequest{ObjectID: "Account"}
	entry := &runtimev1.LayoutAuthoringLayoutSummary{}
	response := &runtimev1.LayoutAuthoringServiceReadWorkspaceResponse{
		ObjectId: "Account", WorkspaceVersion: "workspace-v1",
		Layouts:  make([]*runtimev1.LayoutAuthoringLayoutSummary, semantic.MaxWorkspaceLayouts+1),
		ViewRef:  toWireLayoutAuthoringViewRef(layoutAuthoringTestViewRef(50)),
		Receipts: toWireReceipts(layoutAuthoringTestReceipts(50), layoutAuthoringCapability),
	}
	for index := range response.Layouts {
		response.Layouts[index] = entry
	}
	if _, err := FromWireLayoutAuthoringWorkspace(request, response); err == nil {
		t.Fatal("oversized decoded workspace reached semantic mapping")
	} else {
		var failure *semantic.Failure
		if !errors.As(err, &failure) || failure.Category != semantic.FailureInternal {
			t.Fatalf("decoded workspace preflight = %#v, want internal response failure", err)
		}
	}
}

func TestLayoutAuthoringMapperPreflightsValueDepthBeforeRecursiveMapping(t *testing.T) {
	document := emptyWireLayoutAuthoringDocument()
	document.Sections = []*runtimev1.LayoutAuthoringSection{{
		ComponentConfiguration: []*runtimev1.LayoutAuthoringNamedValue{{
			Name:  "nested",
			Value: deepWireLayoutAuthoringValue(semantic.MaxValueDepth + 1),
		}},
	}}
	request := &runtimev1.LayoutAuthoringServiceSubmitRequest{
		CommandId: "command-1", IdempotencyKey: "idempotency-1", BaseCatalogRevision: 41,
		WaitMode: runtimev1.LayoutAuthoringWaitMode_LAYOUT_AUTHORING_WAIT_MODE_WAIT_FOR_TERMINAL,
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document: document,
			ListFields: &runtimev1.LayoutAuthoringStringListChange{
				Mode: runtimev1.LayoutAuthoringChangeMode_LAYOUT_AUTHORING_CHANGE_MODE_PRESERVE,
			},
		}},
	}
	assertDepthFailure := func(source string, err error) {
		t.Helper()
		var failure *semantic.Failure
		if !errors.As(err, &failure) || failure.Category != semantic.FailureResourceExhausted ||
			failure.LimitKind != semantic.LimitQueryDepth || failure.Maximum != semantic.MaxValueDepth {
			t.Fatalf("%s = %#v, want Value depth limit", source, err)
		}
	}
	assertDepthFailure("typed preflight", preflightWireLayoutAuthoringSubmitRequest(request))
	_, err := FromWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), request)
	assertDepthFailure("FromWire", err)
	encoded, err := proto.Marshal(request)
	if err != nil {
		t.Fatal(err)
	}
	assertDepthFailure("raw preflight", PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{}))
}

func TestLayoutAuthoringTypedPreflightRejectsNilMessageEntries(t *testing.T) {
	document := emptyWireLayoutAuthoringDocument()
	document.Sections = []*runtimev1.LayoutAuthoringSection{nil}
	request := &runtimev1.LayoutAuthoringServiceSubmitRequest{
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document:   document,
			ListFields: &runtimev1.LayoutAuthoringStringListChange{},
		}},
	}
	if err := preflightWireLayoutAuthoringSubmitRequest(request); err == nil {
		t.Fatal("nil repeated message passed typed preflight")
	}
}

func BenchmarkLayoutAuthoringMapperRejectsCrossParentAmplification(b *testing.B) {
	request := maximalWireLayoutAuthoringAmplificationRequest()
	b.ReportAllocs()
	b.ResetTimer()
	for range b.N {
		if _, err := FromWireLayoutAuthoringSubmitRequest(context.Background(), request); err == nil {
			b.Fatal("amplified decoded request passed mapper preflight")
		}
	}
}

func BenchmarkLayoutAuthoringRawPreflightRejectsCrossParentAmplification(b *testing.B) {
	encoded, err := proto.Marshal(maximalWireLayoutAuthoringAmplificationRequest())
	if err != nil {
		b.Fatal(err)
	}
	b.SetBytes(int64(len(encoded)))
	b.ReportAllocs()
	b.ResetTimer()
	for range b.N {
		if err := PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); err == nil {
			b.Fatal("amplified raw request passed pre-unmarshal preflight")
		}
	}
}

func TestLayoutAuthoringStatusMappingIsCapabilityBound(t *testing.T) {
	for _, source := range []*semantic.Failure{
		{Category: semantic.FailureConflict},
		{Category: semantic.FailureInvalidRequest, InvalidComponent: semantic.InvalidComponentOperation},
		{Category: semantic.FailureResourceExhausted, LimitKind: semantic.LimitFieldCount, Maximum: semantic.MaxFieldBehaviorsPerField},
	} {
		decoded := FromPlatformStatusError(ToPlatformStatusError(source, semantic.CapabilityName), semantic.CapabilityName)
		var failure *semantic.Failure
		if !errors.As(decoded, &failure) || failure.Category != source.Category {
			t.Fatalf("status round trip = %#v, want %#v", decoded, source)
		}
	}
	decoded := FromPlatformStatusError(ToPlatformStatusError(&semantic.Failure{Category: semantic.FailureConflict}, semantic.CapabilityName), "runtime.layout.other.v1")
	var unknown *semantic.Failure
	if !errors.As(decoded, &unknown) || unknown.Category != semantic.FailureInternal {
		t.Fatalf("unknown capability did not fail closed: %#v", decoded)
	}
}

func TestLayoutAuthoringLargeTypedDocumentStaysInsideWireEnvelope(t *testing.T) {
	document := layoutAuthoringTestDocument()
	base := semantic.LayoutDocumentSemanticSize(document)
	remaining := semantic.MaxLayoutDocumentSemanticBytes - base
	filler := strings.Repeat("x", remaining)
	document.HeaderActions.Actions[0].Configuration[0].Value = semantic.Value{Kind: semantic.ValueString, String: &filler}
	for semantic.LayoutDocumentSemanticSize(document) > semantic.MaxLayoutDocumentSemanticBytes {
		filler = filler[:len(filler)-1]
		document.HeaderActions.Actions[0].Configuration[0].Value.String = &filler
	}
	document.Name += strings.Repeat("x", semantic.MaxLayoutDocumentSemanticBytes-semantic.LayoutDocumentSemanticSize(document))
	if got := semantic.LayoutDocumentSemanticSize(document); got != semantic.MaxLayoutDocumentSemanticBytes {
		t.Fatalf("large document semantic bytes = %d, want %d", got, semantic.MaxLayoutDocumentSemanticBytes)
	}
	if err := semantic.ValidateLayoutDocument(document); err != nil {
		t.Fatalf("large semantic document = %v", err)
	}
	request := layoutAuthoringTestSubmit(semantic.CommandOperation{Create: &semantic.CreateLayout{
		Document: document, ListFields: semantic.FieldIDListChange{Mode: semantic.ChangePreserve},
	}})
	wire, err := ToWireLayoutAuthoringSubmitRequest(layoutAuthoringTestContext(t), request)
	if err != nil {
		t.Fatal(err)
	}
	encoded, err := proto.Marshal(wire)
	if err != nil {
		t.Fatal(err)
	}
	if len(encoded) >= envelope.MaxRequestWireBytes {
		t.Fatalf("bounded 2 MiB document produced %d-byte wire envelope", len(encoded))
	}
	if err := PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceSubmitRequest{}); err != nil {
		t.Fatalf("large valid request preflight = %v", err)
	}
}

func TestLayoutAuthoringMaximumSemanticResponseStaysInsideWireEnvelope(t *testing.T) {
	workspace := layoutAuthoringWorkspaceWithSemanticSize(t, semantic.MaxSemanticResponseBytes)
	if got := semantic.SemanticResponseSize(workspace); got != semantic.MaxSemanticResponseBytes {
		t.Fatalf("workspace semantic bytes = %d, want %d", got, semantic.MaxSemanticResponseBytes)
	}
	request := semantic.WorkspaceRequest{ObjectID: workspace.ObjectID, ViewRef: &workspace.ViewRef}
	wire, err := ToWireLayoutAuthoringWorkspace(request, workspace)
	if err != nil {
		t.Fatal(err)
	}
	encoded, err := proto.Marshal(wire)
	if err != nil {
		t.Fatal(err)
	}
	if len(encoded) >= envelope.MaxResponseWireBytes {
		t.Fatalf("bounded 3 MiB semantic response produced %d-byte wire envelope", len(encoded))
	}
	if err := PreflightPlatformWirePayload(encoded, &runtimev1.LayoutAuthoringServiceReadWorkspaceResponse{}); err != nil {
		t.Fatalf("maximum valid response preflight = %v", err)
	}
}

func layoutAuthoringTestDocument() semantic.LayoutDocument {
	emptyBehaviors := []semantic.FieldBehavior{}
	nameBehaviors := []semantic.FieldBehavior{{Mode: "Create", Behavior: "  Required  "}, {Mode: "Edit", Behavior: "shown"}}
	tab := "details"
	kind := "Fields"
	condition := "Status == 'Open'"
	icon := "utility:edit"
	object := "Contact"
	component := "edit-dialog"
	nestedObject := []semantic.NamedValue{{Name: "enabled", Value: semantic.Value{Kind: semantic.ValueBoolean, Boolean: layoutAuthoringPointer(true)}}}
	nestedList := []semantic.Value{{Kind: semantic.ValueObject, Object: &nestedObject}, {Kind: semantic.ValueNull}}
	return semantic.LayoutDocument{
		LayoutID: "layout-main", ObjectID: "Account", Name: "Main Layout", Kind: "Detail", LayoutVersion: 7,
		CompactFields: []string{"Name", "OwnerId"}, Tabs: []string{"details"},
		Sections: []semantic.LayoutSection{{
			SectionID: "section-main", Label: "Main", TabID: &tab, Kind: &kind, ComponentConfiguration: []semantic.NamedValue{{Name: "options", Value: semantic.Value{Kind: semantic.ValueList, List: &nestedList}}},
			Columns: 2, Fields: []string{"Name", "OwnerId.Name"},
			FieldLabels:         []semantic.FieldLabel{{FieldReference: "Name", Label: "Account name"}, {FieldReference: "Orphaned__c", Label: "Retained orphan"}},
			FieldBehaviors:      []semantic.FieldBehaviorGroup{{FieldReference: "Empty__c", Behaviors: &emptyBehaviors}, {FieldReference: "Name", Behaviors: &nameBehaviors}, {FieldReference: "Nil__c", Behaviors: nil}},
			VisibilityCondition: &condition,
		}},
		RelatedLists:         []semantic.RelatedList{{RelatedListID: "contacts", Label: "Contacts", ObjectID: "Contact", LookupFieldID: "ParentId", FieldIDs: []string{"Name"}, PrefillMappings: []semantic.PrefillMapping{{TargetFieldID: "ParentId", SourceFieldID: "Id"}}}},
		RecordPanels:         []semantic.RecordPanel{{PanelID: "panel-main", RendererID: "summary", Position: "header", RendererConfiguration: []semantic.NamedValue{{Name: "density", Value: semantic.Value{Kind: semantic.ValueString, String: layoutAuthoringPointer("compact")}}}}},
		HeaderActions:        semantic.ActionPlacement{Authored: true, Actions: []semantic.LayoutAction{{Name: "Edit", Label: "Edit", Kind: "Standard", Icon: &icon, TargetObjectID: &object, Component: &component, VisibilityCondition: &condition, Configuration: []semantic.NamedValue{{Name: "dialog", Value: semantic.Value{Kind: semantic.ValueString, String: layoutAuthoringPointer("wide")}}}, Extensions: []semantic.NamedValue{}}}},
		QuickActions:         semantic.ActionPlacement{Authored: true, Actions: []semantic.LayoutAction{}},
		RecordStates:         []semantic.RecordStateRule{{RuleID: "state-open", Condition: condition, Priority: 1, Banner: &semantic.RecordStateBanner{Severity: "info", Title: "Open", LinkIDs: []string{"parent"}}, Links: []semantic.RecordStateLink{{LinkID: "parent", Label: "Parent", ReferenceFieldID: "ParentId", ObjectID: "Account", Placement: "banner"}}, ActionOverrides: []semantic.RecordStateActionOverride{{ActionKey: "delete", Mode: "disable"}}, ReadOnly: &semantic.RecordStateReadOnly{Enabled: true}}},
		PrimaryHeaderActions: []string{"edit"},
	}
}

func amplifiedLayoutAuthoringFieldLabels() *runtimev1.LayoutAuthoringDocument {
	return wireLayoutAuthoringFieldLabels(amplifiedLayoutAuthoringEntriesPerParent(
		semantic.MaxSections,
		semantic.MaxFieldLabelsPerSection,
		layoutAuthoringSemanticFloors.fieldLabel,
	))
}

func wireLayoutAuthoringFieldLabels(labelsPerSection int) *runtimev1.LayoutAuthoringDocument {
	label := &runtimev1.LayoutAuthoringFieldLabel{}
	labels := make([]*runtimev1.LayoutAuthoringFieldLabel, labelsPerSection)
	for index := range labels {
		labels[index] = label
	}
	section := &runtimev1.LayoutAuthoringSection{FieldLabels: labels}
	document := emptyWireLayoutAuthoringDocument()
	document.Sections = make([]*runtimev1.LayoutAuthoringSection, semantic.MaxSections)
	for index := range document.Sections {
		document.Sections[index] = section
	}
	return document
}

func maximalWireLayoutAuthoringAmplificationRequest() *runtimev1.LayoutAuthoringServiceSubmitRequest {
	return &runtimev1.LayoutAuthoringServiceSubmitRequest{
		Operation: &runtimev1.LayoutAuthoringServiceSubmitRequest_Create{Create: &runtimev1.LayoutAuthoringCreateLayout{
			Document:   wireLayoutAuthoringFieldLabels(semantic.MaxFieldLabelsPerSection),
			ListFields: &runtimev1.LayoutAuthoringStringListChange{},
		}},
	}
}

func amplifiedLayoutAuthoringPrefillMappings() *runtimev1.LayoutAuthoringDocument {
	mapping := &runtimev1.LayoutAuthoringPrefillMapping{}
	mappings := make([]*runtimev1.LayoutAuthoringPrefillMapping, amplifiedLayoutAuthoringEntriesPerParent(
		semantic.MaxRelatedLists,
		semantic.MaxPrefillMappings,
		layoutAuthoringSemanticFloors.prefillMapping,
	))
	for index := range mappings {
		mappings[index] = mapping
	}
	relatedList := &runtimev1.LayoutAuthoringRelatedList{PrefillMappings: mappings}
	document := emptyWireLayoutAuthoringDocument()
	document.RelatedLists = make([]*runtimev1.LayoutAuthoringRelatedList, semantic.MaxRelatedLists)
	for index := range document.RelatedLists {
		document.RelatedLists[index] = relatedList
	}
	return document
}

func amplifiedLayoutAuthoringRecordStateLinks() *runtimev1.LayoutAuthoringDocument {
	link := &runtimev1.LayoutAuthoringRecordStateLink{}
	links := make([]*runtimev1.LayoutAuthoringRecordStateLink, amplifiedLayoutAuthoringEntriesPerParent(
		semantic.MaxRecordStates,
		semantic.MaxRecordStateLinks,
		layoutAuthoringSemanticFloors.link,
	))
	for index := range links {
		links[index] = link
	}
	state := &runtimev1.LayoutAuthoringRecordStateRule{Links: links}
	document := emptyWireLayoutAuthoringDocument()
	document.RecordStates = make([]*runtimev1.LayoutAuthoringRecordStateRule, semantic.MaxRecordStates)
	for index := range document.RecordStates {
		document.RecordStates[index] = state
	}
	return document
}

func amplifiedLayoutAuthoringEntriesPerParent(parents, localMaximum, semanticFloor int) int {
	count := semantic.MaxLayoutDocumentSemanticBytes/(parents*semanticFloor) + 1
	if count > localMaximum {
		return localMaximum
	}
	return count
}

func emptyWireLayoutAuthoringDocument() *runtimev1.LayoutAuthoringDocument {
	return &runtimev1.LayoutAuthoringDocument{
		HeaderActions: &runtimev1.LayoutAuthoringActionPlacement{},
		QuickActions:  &runtimev1.LayoutAuthoringActionPlacement{},
	}
}

func deepWireLayoutAuthoringValue(depth int) *runtimev1.LayoutAuthoringValue {
	value := &runtimev1.LayoutAuthoringValue{
		Value: &runtimev1.LayoutAuthoringValue_NullValue{NullValue: &runtimev1.LayoutAuthoringNullValue{}},
	}
	for range depth {
		value = &runtimev1.LayoutAuthoringValue{
			Value: &runtimev1.LayoutAuthoringValue_ListValue{ListValue: &runtimev1.LayoutAuthoringValueList{
				Values: []*runtimev1.LayoutAuthoringValue{value},
			}},
		}
	}
	return value
}

func layoutAuthoringTestChanges() semantic.LayoutDocumentChanges {
	emptyStrings := []string{}
	emptySections := []semantic.LayoutSection{}
	emptyActions := semantic.ActionPlacement{Authored: true, Actions: []semantic.LayoutAction{}}
	name := "Renamed"
	version := uint32(8)
	return semantic.LayoutDocumentChanges{
		Name: semantic.Change[string]{Mode: semantic.ChangeSet, Value: &name}, Kind: semantic.Change[string]{Mode: semantic.ChangeClear},
		LayoutVersion: semantic.Change[uint32]{Mode: semantic.ChangeSet, Value: &version}, CompactFields: semantic.Change[[]string]{Mode: semantic.ChangeClear},
		Tabs: semantic.Change[[]string]{Mode: semantic.ChangeSet, Value: &emptyStrings}, Sections: semantic.Change[[]semantic.LayoutSection]{Mode: semantic.ChangeSet, Value: &emptySections},
		RelatedLists: semantic.Change[[]semantic.RelatedList]{Mode: semantic.ChangePreserve}, RecordPanels: semantic.Change[[]semantic.RecordPanel]{Mode: semantic.ChangePreserve},
		HeaderActions: semantic.Change[semantic.ActionPlacement]{Mode: semantic.ChangeClear}, QuickActions: semantic.Change[semantic.ActionPlacement]{Mode: semantic.ChangeSet, Value: &emptyActions},
		RecordStates: semantic.Change[[]semantic.RecordStateRule]{Mode: semantic.ChangePreserve}, PrimaryHeaderActions: semantic.Change[[]string]{Mode: semantic.ChangeClear},
	}
}

func layoutAuthoringUpdatedDocument(document semantic.LayoutDocument) semantic.LayoutDocument {
	document.Name = "Renamed"
	document.Kind = ""
	document.LayoutVersion = 8
	document.CompactFields = []string{}
	document.Tabs = []string{}
	document.Sections = []semantic.LayoutSection{}
	document.HeaderActions = semantic.ActionPlacement{Actions: []semantic.LayoutAction{}}
	document.QuickActions = semantic.ActionPlacement{Authored: true, Actions: []semantic.LayoutAction{}}
	document.PrimaryHeaderActions = []string{}
	return document
}

func layoutAuthoringCloneDocument(document semantic.LayoutDocument) semantic.LayoutDocument {
	document.LayoutID = "layout-copy"
	document.Name = "Copy"
	return document
}

func layoutAuthoringTestSubmit(operation semantic.CommandOperation) semantic.SubmitRequest {
	return semantic.SubmitRequest{CommandID: "command-1", IdempotencyKey: "idempotency-1", BaseCatalogRevision: 41, WaitMode: semantic.WaitForTerminal, Operation: operation}
}

func layoutAuthoringSucceededStatus(t *testing.T, request semantic.SubmitRequest, result semantic.CommandResult) semantic.CommandStatus {
	t.Helper()
	digest, err := semantic.RequestDigest(request)
	if err != nil {
		t.Fatal(err)
	}
	return semantic.CommandStatus{CommandID: request.CommandID, RequestDigest: digest, State: semantic.StateSucceeded, Result: &result, CatalogViewRef: layoutAuthoringPointer(layoutAuthoringTestViewRef(50)), Receipts: layoutAuthoringTestReceipts(50)}
}

func layoutAuthoringTestSnapshot(document semantic.LayoutDocument, listFields []string) semantic.LayoutSnapshot {
	return semantic.LayoutSnapshot{Document: document, OrderedListFields: listFields, ResourceVersion: "resource-v2", AggregateVersion: "aggregate-v2", WorkspaceVersion: "workspace-v2"}
}

func layoutAuthoringTestReceipts(revision uint64) semantic.Receipts {
	return semantic.Receipts{ProtocolVersion: "1.0", CapabilityVersion: semantic.CapabilityName, CatalogRevision: revision, SchemaGeneration: 3, EngineGeneration: 4, SecurityEpoch: 5}
}

func layoutAuthoringTestViewRef(revision uint64) semantic.CatalogViewRef {
	return semantic.CatalogViewRef{CatalogRevision: revision, AuthoringViewDigest: "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"}
}

func layoutAuthoringTestContext(t *testing.T) context.Context {
	t.Helper()
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	t.Cleanup(cancel)
	return ctx
}

func layoutAuthoringWorkspaceWithSemanticSize(t *testing.T, target int) semantic.Workspace {
	t.Helper()
	workspace := semantic.Workspace{
		ObjectID: "Account", WorkspaceVersion: "v", ViewRef: layoutAuthoringTestViewRef(50), Receipts: layoutAuthoringTestReceipts(50),
		Layouts: make([]semantic.LayoutSummary, semantic.MaxWorkspaceLayouts),
		Assignments: []semantic.LayoutAssignmentSummary{{
			AssignmentID: "assignment-default", ObjectID: "Account", LayoutID: "layout-0000",
			Selectors: semantic.AssignmentSelectors{}, Specificity: 0, ResourceVersion: "v",
		}},
	}
	for index := range workspace.Layouts {
		workspace.Layouts[index] = semantic.LayoutSummary{
			LayoutID: fmt.Sprintf("layout-%04d", index), ObjectID: "Account", Name: "n", Kind: "k", ResourceVersion: "v",
		}
	}
	workspace.Layouts[0].IsDefault = true
	remaining := target - semantic.SemanticResponseSize(workspace)
	if remaining < 0 {
		t.Fatalf("minimum workspace exceeds target by %d bytes", -remaining)
	}
	for index := range workspace.Layouts {
		for _, field := range []struct {
			value   *string
			maximum int
		}{
			{&workspace.Layouts[index].Name, semantic.MaxNameBytes},
			{&workspace.Layouts[index].Kind, semantic.MaxKindBytes},
			{&workspace.Layouts[index].ResourceVersion, semantic.MaxVersionBytes},
		} {
			if remaining == 0 {
				return workspace
			}
			grown, used := layoutAuthoringGrowSemanticString(*field.value, field.maximum, remaining)
			*field.value = grown
			remaining -= used
		}
	}
	if remaining != 0 {
		remaining = layoutAuthoringAddTimestampSize(workspace.Layouts, remaining)
	}
	if remaining != 0 {
		t.Fatalf("workspace capacity exhausted with %d bytes remaining", remaining)
	}
	return workspace
}

func layoutAuthoringGrowSemanticString(value string, maximum, remaining int) (string, int) {
	base := layoutAuthoringEncodedSemanticStringSize(len(value))
	bestLength := len(value)
	bestGrowth := 0
	for low, high := len(value), maximum; low <= high; {
		middle := low + (high-low)/2
		growth := layoutAuthoringEncodedSemanticStringSize(middle) - base
		if growth <= remaining {
			bestLength, bestGrowth = middle, growth
			low = middle + 1
		} else {
			high = middle - 1
		}
	}
	return value + strings.Repeat("x", bestLength-len(value)), bestGrowth
}

func layoutAuthoringEncodedSemanticStringSize(length int) int {
	var encoded [binary.MaxVarintLen64]byte
	return 1 + binary.PutUvarint(encoded[:], uint64(length)) + length
}

func layoutAuthoringAddTimestampSize(layouts []semantic.LayoutSummary, remaining int) int {
	lengths := []int{20, 22, 23, 24, 25, 26, 27, 28, 29, 30}
	previous := make([]int, remaining+1)
	for index := range previous {
		previous[index] = -1
	}
	previous[0] = 0
	for amount := 1; amount <= remaining; amount++ {
		for _, length := range lengths {
			if amount >= length && previous[amount-length] >= 0 {
				previous[amount] = length
				break
			}
		}
	}
	if previous[remaining] < 0 {
		return remaining
	}
	for index := 0; remaining > 0 && index < len(layouts); index++ {
		length := previous[remaining]
		if length == 20 {
			layouts[index].CreatedAt = "2026-01-01T00:00:00Z"
		} else {
			layouts[index].CreatedAt = "2026-01-01T00:00:00." + strings.Repeat("1", length-21) + "Z"
		}
		remaining -= length
	}
	return remaining
}