package mapping

import (
	"context"

	commandsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/commandv1"
	commonsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/commonv1"
	permissionsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/effectivepermissionsv1"
	flowsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/flowv1"
	recordsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/recordsv1"
	reportsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/reportv1"
	searchsemantic "github.com/pingcap-inc/nexuscrm-contract/pkg/runtime/searchv1"
	runtimev1 "github.com/pingcap-inc/nexuscrm-contract/wire-go/gen/runtime/v1"
)

func ToWireReadEffectivePermissionsRequest(
	ctx context.Context,
	request permissionsemantic.Request,
) (*runtimev1.ReadEffectivePermissionsRequest, error) {
	if err := requirePlatformSemanticShape(permissionsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := permissionsemantic.ValidateRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.ReadEffectivePermissionsRequest{
		TargetPrincipalId:  request.TargetPrincipalID,
		MinCatalogRevision: request.MinCatalogRevision,
		Selection:          toWireEffectivePermissionSelection(request.Selection),
	}, nil
}

func FromWireReadEffectivePermissionsRequest(
	ctx context.Context,
	request *runtimev1.ReadEffectivePermissionsRequest,
) (permissionsemantic.Request, error) {
	if err := requirePlatformSemanticShape(permissionsemantic.CapabilityName); err != nil {
		return permissionsemantic.Request{}, err
	}
	if request == nil {
		return permissionsemantic.Request{}, invalidPlatformWire()
	}
	result := permissionsemantic.Request{
		TargetPrincipalID:  request.GetTargetPrincipalId(),
		MinCatalogRevision: request.MinCatalogRevision,
	}
	selection, err := fromWireEffectivePermissionSelection(request.GetSelection())
	if err != nil {
		return permissionsemantic.Request{}, err
	}
	result.Selection = selection
	if err := permissionsemantic.ValidateRequest(ctx, result); err != nil {
		return permissionsemantic.Request{}, err
	}
	return result, nil
}

func toWireEffectivePermissionSelection(
	selection *permissionsemantic.Selection,
) *runtimev1.EffectivePermissionSelection {
	if selection == nil {
		return nil
	}
	result := &runtimev1.EffectivePermissionSelection{
		Sections: make(
			[]runtimev1.EffectivePermissionSection, 0, len(selection.Sections),
		),
		ResourceTypes: append([]string(nil), selection.ResourceTypes...),
	}
	for _, section := range selection.Sections {
		result.Sections = append(result.Sections, toWireEffectivePermissionSection(section))
	}
	return result
}

func fromWireEffectivePermissionSelection(
	selection *runtimev1.EffectivePermissionSelection,
) (*permissionsemantic.Selection, error) {
	if selection == nil {
		return nil, nil
	}
	result := &permissionsemantic.Selection{
		Sections:      make([]permissionsemantic.Section, 0, len(selection.GetSections())),
		ResourceTypes: append([]string(nil), selection.GetResourceTypes()...),
	}
	for _, section := range selection.GetSections() {
		semanticSection, ok := fromWireEffectivePermissionSection(section)
		if !ok {
			return nil, invalidPlatformWire()
		}
		result.Sections = append(result.Sections, semanticSection)
	}
	return result, nil
}

func toWireEffectivePermissionSection(
	section permissionsemantic.Section,
) runtimev1.EffectivePermissionSection {
	switch section {
	case permissionsemantic.SectionSystemPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_SYSTEM_PERMISSIONS
	case permissionsemantic.SectionCustomPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_CUSTOM_PERMISSIONS
	case permissionsemantic.SectionObjectPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_OBJECT_PERMISSIONS
	case permissionsemantic.SectionFieldPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_FIELD_PERMISSIONS
	case permissionsemantic.SectionApplicationPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_APPLICATION_PERMISSIONS
	case permissionsemantic.SectionNavigationPermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_NAVIGATION_PERMISSIONS
	case permissionsemantic.SectionRecordTypePermissions:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_RECORD_TYPE_PERMISSIONS
	default:
		return runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_UNSPECIFIED
	}
}

func fromWireEffectivePermissionSection(
	section runtimev1.EffectivePermissionSection,
) (permissionsemantic.Section, bool) {
	switch section {
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_SYSTEM_PERMISSIONS:
		return permissionsemantic.SectionSystemPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_CUSTOM_PERMISSIONS:
		return permissionsemantic.SectionCustomPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_OBJECT_PERMISSIONS:
		return permissionsemantic.SectionObjectPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_FIELD_PERMISSIONS:
		return permissionsemantic.SectionFieldPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_APPLICATION_PERMISSIONS:
		return permissionsemantic.SectionApplicationPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_NAVIGATION_PERMISSIONS:
		return permissionsemantic.SectionNavigationPermissions, true
	case runtimev1.EffectivePermissionSection_EFFECTIVE_PERMISSION_SECTION_RECORD_TYPE_PERMISSIONS:
		return permissionsemantic.SectionRecordTypePermissions, true
	default:
		return "", false
	}
}

func ToWireReadEffectivePermissionsResponse(
	response permissionsemantic.Response,
) (*runtimev1.ReadEffectivePermissionsResponse, error) {
	return toWireReadEffectivePermissionsResponse(nil, response)
}

// ToWireReadEffectivePermissionsResponseForRequest preserves the released
// complete-response mapper while proving selected responses are closed over
// the exact request before they cross the wire boundary.
func ToWireReadEffectivePermissionsResponseForRequest(
	request permissionsemantic.Request,
	response permissionsemantic.Response,
) (*runtimev1.ReadEffectivePermissionsResponse, error) {
	return toWireReadEffectivePermissionsResponse(&request, response)
}

func toWireReadEffectivePermissionsResponse(
	request *permissionsemantic.Request,
	response permissionsemantic.Response,
) (*runtimev1.ReadEffectivePermissionsResponse, error) {
	if err := requirePlatformSemanticShape(permissionsemantic.CapabilityName); err != nil {
		return nil, err
	}
	var validationErr error
	if request == nil {
		validationErr = permissionsemantic.ValidateResponse(response)
	} else {
		validationErr = permissionsemantic.ValidateResponseForRequest(*request, response)
	}
	if validationErr != nil {
		return nil, validationErr
	}
	result := &runtimev1.ReadEffectivePermissionsResponse{
		SystemPermissions: make(
			[]*runtimev1.EffectivePermissionGrant, 0, len(response.SystemPermissions),
		),
		CustomPermissions: make(
			[]*runtimev1.EffectivePermissionGrant, 0, len(response.CustomPermissions),
		),
		ObjectPermissions: make(
			[]*runtimev1.EffectiveObjectPermission, 0, len(response.ObjectPermissions),
		),
		FieldPermissions: make(
			[]*runtimev1.EffectiveFieldPermission, 0, len(response.FieldPermissions),
		),
		ApplicationPermissions: make(
			[]*runtimev1.EffectiveApplicationPermission, 0, len(response.ApplicationPermissions),
		),
		NavigationPermissions: make(
			[]*runtimev1.EffectiveNavigationPermission, 0, len(response.NavigationPermissions),
		),
		RecordTypePermissions: make(
			[]*runtimev1.EffectiveRecordTypePermission, 0, len(response.RecordTypePermissions),
		),
		Receipts: toWireReceipts(
			response.Receipts, platformCapability(permissionsemantic.CapabilityName),
		),
	}
	for _, permission := range response.SystemPermissions {
		result.SystemPermissions = append(result.SystemPermissions, &runtimev1.EffectivePermissionGrant{
			PermissionId: permission.PermissionID,
			Granted:      permission.Granted,
		})
	}
	for _, permission := range response.CustomPermissions {
		result.CustomPermissions = append(result.CustomPermissions, &runtimev1.EffectivePermissionGrant{
			PermissionId: permission.PermissionID,
			Granted:      permission.Granted,
		})
	}
	for _, permission := range response.ObjectPermissions {
		result.ObjectPermissions = append(result.ObjectPermissions, &runtimev1.EffectiveObjectPermission{
			ResourceType:  permission.ResourceType,
			CanRead:       permission.CanRead,
			CanCreate:     permission.CanCreate,
			CanEdit:       permission.CanEdit,
			CanDelete:     permission.CanDelete,
			CanDeactivate: permission.CanDeactivate,
			CanViewAll:    permission.CanViewAll,
			CanModifyAll:  permission.CanModifyAll,
		})
	}
	for _, permission := range response.FieldPermissions {
		result.FieldPermissions = append(result.FieldPermissions, &runtimev1.EffectiveFieldPermission{
			ResourceType: permission.ResourceType,
			FieldName:    permission.FieldName,
			CanCreate:    permission.CanCreate,
			CanRead:      permission.CanRead,
			CanEdit:      permission.CanEdit,
		})
	}
	for _, permission := range response.ApplicationPermissions {
		result.ApplicationPermissions = append(
			result.ApplicationPermissions,
			&runtimev1.EffectiveApplicationPermission{
				ApplicationId: permission.ApplicationID,
				CanView:       permission.CanView,
				IsDefault:     permission.IsDefault,
			},
		)
	}
	for _, permission := range response.NavigationPermissions {
		result.NavigationPermissions = append(
			result.NavigationPermissions,
			&runtimev1.EffectiveNavigationPermission{
				NavigationKey: permission.NavigationKey,
				CanView:       permission.CanView,
			},
		)
	}
	for _, permission := range response.RecordTypePermissions {
		result.RecordTypePermissions = append(
			result.RecordTypePermissions,
			&runtimev1.EffectiveRecordTypePermission{
				ResourceType: permission.ResourceType,
				RecordTypeId: permission.RecordTypeID,
				Available:    permission.Available,
				IsDefault:    permission.IsDefault,
			},
		)
	}
	return result, nil
}

func FromWireReadEffectivePermissionsResponse(
	response *runtimev1.ReadEffectivePermissionsResponse,
) (permissionsemantic.Response, error) {
	return fromWireReadEffectivePermissionsResponse(nil, response)
}

// FromWireReadEffectivePermissionsResponseForRequest rejects any wire fact
// outside the selected request before returning semantic authority to a caller.
func FromWireReadEffectivePermissionsResponseForRequest(
	request permissionsemantic.Request,
	response *runtimev1.ReadEffectivePermissionsResponse,
) (permissionsemantic.Response, error) {
	return fromWireReadEffectivePermissionsResponse(&request, response)
}

func fromWireReadEffectivePermissionsResponse(
	request *permissionsemantic.Request,
	response *runtimev1.ReadEffectivePermissionsResponse,
) (permissionsemantic.Response, error) {
	if err := requirePlatformSemanticShape(permissionsemantic.CapabilityName); err != nil {
		return permissionsemantic.Response{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return permissionsemantic.Response{}, incompatibleFailureFor(
			platformCapability(permissionsemantic.CapabilityName),
		)
	}
	receipts, err := fromWireReceipts(
		response.GetReceipts(), platformCapability(permissionsemantic.CapabilityName),
	)
	if err != nil {
		return permissionsemantic.Response{}, err
	}
	result := permissionsemantic.Response{
		SystemPermissions: make(
			[]permissionsemantic.PermissionGrant, 0, len(response.GetSystemPermissions()),
		),
		CustomPermissions: make(
			[]permissionsemantic.PermissionGrant, 0, len(response.GetCustomPermissions()),
		),
		ObjectPermissions: make(
			[]permissionsemantic.ObjectPermission, 0, len(response.GetObjectPermissions()),
		),
		FieldPermissions: make(
			[]permissionsemantic.FieldPermission, 0, len(response.GetFieldPermissions()),
		),
		ApplicationPermissions: make(
			[]permissionsemantic.ApplicationPermission, 0, len(response.GetApplicationPermissions()),
		),
		NavigationPermissions: make(
			[]permissionsemantic.NavigationPermission, 0, len(response.GetNavigationPermissions()),
		),
		RecordTypePermissions: make(
			[]permissionsemantic.RecordTypePermission, 0, len(response.GetRecordTypePermissions()),
		),
		Receipts: receipts,
	}
	for _, permission := range response.GetSystemPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.SystemPermissions = append(result.SystemPermissions, permissionsemantic.PermissionGrant{
			PermissionID: permission.GetPermissionId(),
			Granted:      permission.GetGranted(),
		})
	}
	for _, permission := range response.GetCustomPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.CustomPermissions = append(result.CustomPermissions, permissionsemantic.PermissionGrant{
			PermissionID: permission.GetPermissionId(),
			Granted:      permission.GetGranted(),
		})
	}
	for _, permission := range response.GetObjectPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.ObjectPermissions = append(result.ObjectPermissions, permissionsemantic.ObjectPermission{
			ResourceType:  permission.GetResourceType(),
			CanRead:       permission.GetCanRead(),
			CanCreate:     permission.GetCanCreate(),
			CanEdit:       permission.GetCanEdit(),
			CanDelete:     permission.GetCanDelete(),
			CanDeactivate: permission.GetCanDeactivate(),
			CanViewAll:    permission.GetCanViewAll(),
			CanModifyAll:  permission.GetCanModifyAll(),
		})
	}
	for _, permission := range response.GetFieldPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.FieldPermissions = append(result.FieldPermissions, permissionsemantic.FieldPermission{
			ResourceType: permission.GetResourceType(),
			FieldName:    permission.GetFieldName(),
			CanCreate:    permission.GetCanCreate(),
			CanRead:      permission.GetCanRead(),
			CanEdit:      permission.GetCanEdit(),
		})
	}
	for _, permission := range response.GetApplicationPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.ApplicationPermissions = append(
			result.ApplicationPermissions,
			permissionsemantic.ApplicationPermission{
				ApplicationID: permission.GetApplicationId(),
				CanView:       permission.GetCanView(),
				IsDefault:     permission.GetIsDefault(),
			},
		)
	}
	for _, permission := range response.GetNavigationPermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.NavigationPermissions = append(
			result.NavigationPermissions,
			permissionsemantic.NavigationPermission{
				NavigationKey: permission.GetNavigationKey(),
				CanView:       permission.GetCanView(),
			},
		)
	}
	for _, permission := range response.GetRecordTypePermissions() {
		if permission == nil {
			return permissionsemantic.Response{}, internalPlatformWire()
		}
		result.RecordTypePermissions = append(
			result.RecordTypePermissions,
			permissionsemantic.RecordTypePermission{
				ResourceType: permission.GetResourceType(),
				RecordTypeID: permission.GetRecordTypeId(),
				Available:    permission.GetAvailable(),
				IsDefault:    permission.GetIsDefault(),
			},
		)
	}
	var validationErr error
	if request == nil {
		validationErr = permissionsemantic.ValidateResponse(result)
	} else {
		validationErr = permissionsemantic.ValidateResponseForRequest(*request, result)
	}
	if validationErr != nil {
		return permissionsemantic.Response{}, validationErr
	}
	return result, nil
}

func ToWireSearchRequest(ctx context.Context, request searchsemantic.Request) (*runtimev1.SearchRecordsRequest, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := searchsemantic.ValidateRequest(ctx, request); err != nil {
		return nil, err
	}
	plans := make([]*runtimev1.SearchObjectPlan, 0, len(request.ObjectPlans))
	for _, plan := range request.ObjectPlans {
		plans = append(plans, &runtimev1.SearchObjectPlan{
			ObjectId:       plan.ObjectID,
			SearchFields:   append([]string(nil), plan.SearchFields...),
			SelectedFields: append([]string(nil), plan.SelectedFields...),
			Limit:          plan.Limit,
		})
	}
	return &runtimev1.SearchRecordsRequest{
		ObjectIds: append([]string(nil), request.ObjectIDs...), Term: request.Term,
		SearchFields:   append([]string(nil), request.SearchFields...),
		SelectedFields: append([]string(nil), request.SelectedFields...), Limit: request.Limit,
		MinCatalogRevision: request.MinCatalogRevision,
		ObjectPlans:        plans,
	}, nil
}

func FromWireSearchRequest(ctx context.Context, request *runtimev1.SearchRecordsRequest) (searchsemantic.Request, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return searchsemantic.Request{}, err
	}
	if request == nil {
		return searchsemantic.Request{}, invalidPlatformWire()
	}
	result := searchsemantic.Request{
		ObjectIDs: append([]string(nil), request.GetObjectIds()...), Term: request.GetTerm(),
		SearchFields:   append([]string(nil), request.GetSearchFields()...),
		SelectedFields: append([]string(nil), request.GetSelectedFields()...), Limit: request.GetLimit(),
		MinCatalogRevision: request.MinCatalogRevision,
	}
	for _, plan := range request.GetObjectPlans() {
		if plan == nil {
			return searchsemantic.Request{}, internalPlatformWire()
		}
		result.ObjectPlans = append(result.ObjectPlans, searchsemantic.ObjectPlan{
			ObjectID:       plan.GetObjectId(),
			SearchFields:   append([]string(nil), plan.GetSearchFields()...),
			SelectedFields: append([]string(nil), plan.GetSelectedFields()...),
			Limit:          plan.GetLimit(),
		})
	}
	if err := searchsemantic.ValidateRequest(ctx, result); err != nil {
		return searchsemantic.Request{}, err
	}
	return result, nil
}

func ToWireSearchResponse(request searchsemantic.Request, response searchsemantic.Response) (*runtimev1.SearchRecordsResponse, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := searchsemantic.ValidateResponse(request, response); err != nil {
		return nil, err
	}
	records := make([]*runtimev1.SearchRecord, 0, len(response.Records))
	for _, record := range response.Records {
		fields := make([]*runtimev1.SelectedRootField, 0, len(record.Fields))
		for _, field := range record.Fields {
			wireField, err := toWireField(field)
			if err != nil {
				return nil, err
			}
			fields = append(fields, wireField)
		}
		records = append(records, &runtimev1.SearchRecord{
			ObjectId: record.ObjectID, RecordId: record.RecordID, Fields: fields, Score: record.Score,
		})
	}
	return &runtimev1.SearchRecordsResponse{
		Records:  records,
		Receipts: toWireReceipts(response.Receipts, platformCapability(searchsemantic.CapabilityName)),
	}, nil
}

func FromWireSearchResponse(request searchsemantic.Request, response *runtimev1.SearchRecordsResponse) (searchsemantic.Response, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return searchsemantic.Response{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return searchsemantic.Response{}, incompatibleFailureFor(platformCapability(searchsemantic.CapabilityName))
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(searchsemantic.CapabilityName))
	if err != nil {
		return searchsemantic.Response{}, err
	}
	result := searchsemantic.Response{
		Receipts: receipts, Records: make([]searchsemantic.Record, 0, len(response.GetRecords())),
	}
	for _, record := range response.GetRecords() {
		if record == nil {
			return searchsemantic.Response{}, internalPlatformWire()
		}
		semanticRecord := searchsemantic.Record{
			ObjectID: record.GetObjectId(), RecordID: record.GetRecordId(), Score: record.Score,
			Fields: make([]recordsemantic.Field, 0, len(record.GetFields())),
		}
		for _, field := range record.GetFields() {
			semanticField, err := fromWireField(field)
			if err != nil {
				return searchsemantic.Response{}, err
			}
			semanticRecord.Fields = append(semanticRecord.Fields, semanticField)
		}
		result.Records = append(result.Records, semanticRecord)
	}
	if err := searchsemantic.ValidateResponse(request, result); err != nil {
		return searchsemantic.Response{}, err
	}
	return result, nil
}

func ToWireSearchScopeOrderRequest(ctx context.Context, request searchsemantic.ScopeOrderRequest) (*runtimev1.ReadSearchScopeOrderRequest, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := searchsemantic.ValidateScopeOrderRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.ReadSearchScopeOrderRequest{
		ObjectIds:          append([]string(nil), request.ObjectIDs...),
		MinCatalogRevision: request.MinCatalogRevision,
	}, nil
}

func FromWireSearchScopeOrderRequest(ctx context.Context, request *runtimev1.ReadSearchScopeOrderRequest) (searchsemantic.ScopeOrderRequest, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return searchsemantic.ScopeOrderRequest{}, err
	}
	if request == nil {
		return searchsemantic.ScopeOrderRequest{}, invalidPlatformWire()
	}
	result := searchsemantic.ScopeOrderRequest{
		ObjectIDs:          append([]string(nil), request.GetObjectIds()...),
		MinCatalogRevision: request.MinCatalogRevision,
	}
	if err := searchsemantic.ValidateScopeOrderRequest(ctx, result); err != nil {
		return searchsemantic.ScopeOrderRequest{}, err
	}
	return result, nil
}

func ToWireSearchScopeOrderResponse(request searchsemantic.ScopeOrderRequest, response searchsemantic.ScopeOrderResponse) (*runtimev1.ReadSearchScopeOrderResponse, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := searchsemantic.ValidateScopeOrderResponse(request, response); err != nil {
		return nil, err
	}
	return &runtimev1.ReadSearchScopeOrderResponse{
		ObjectIds: append([]string(nil), response.ObjectIDs...),
		Receipts:  toWireReceipts(response.Receipts, platformCapability(searchsemantic.CapabilityName)),
	}, nil
}

func FromWireSearchScopeOrderResponse(request searchsemantic.ScopeOrderRequest, response *runtimev1.ReadSearchScopeOrderResponse) (searchsemantic.ScopeOrderResponse, error) {
	if err := requirePlatformSemanticShape(searchsemantic.CapabilityName); err != nil {
		return searchsemantic.ScopeOrderResponse{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return searchsemantic.ScopeOrderResponse{}, incompatibleFailureFor(platformCapability(searchsemantic.CapabilityName))
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(searchsemantic.CapabilityName))
	if err != nil {
		return searchsemantic.ScopeOrderResponse{}, err
	}
	result := searchsemantic.ScopeOrderResponse{
		ObjectIDs: append([]string(nil), response.GetObjectIds()...),
		Receipts:  receipts,
	}
	if err := searchsemantic.ValidateScopeOrderResponse(request, result); err != nil {
		return searchsemantic.ScopeOrderResponse{}, err
	}
	return result, nil
}

func ToWireExecuteFlowRequest(ctx context.Context, request flowsemantic.Request) (*runtimev1.ExecuteFlowRequest, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.ExecuteFlowRequest{
		DefinitionRef: request.DefinitionRef, DefinitionVersion: request.DefinitionVersion,
		IdempotencyKey: request.IdempotencyKey, CanonicalInputs: append([]byte(nil), request.CanonicalInputs...),
		MinCatalogRevision: request.MinCatalogRevision,
	}, nil
}

func ToWireExecuteCatalogActionRequest(
	ctx context.Context,
	request flowsemantic.CatalogActionRequest,
) (*runtimev1.ExecuteFlowRequest, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateCatalogActionRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.ExecuteFlowRequest{
		IdempotencyKey:     request.IdempotencyKey,
		CanonicalInputs:    append([]byte(nil), request.CanonicalInputs...),
		MinCatalogRevision: request.MinCatalogRevision,
		CatalogAction: &runtimev1.CatalogActionBinding{
			ComponentRef: request.CatalogAction.ComponentRef,
			ActionRef:    request.CatalogAction.ActionRef,
		},
	}, nil
}

func FromWireExecuteFlowRequest(ctx context.Context, request *runtimev1.ExecuteFlowRequest) (flowsemantic.Request, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.Request{}, err
	}
	if request == nil || request.GetCatalogAction() != nil {
		return flowsemantic.Request{}, invalidPlatformWire()
	}
	result := flowsemantic.Request{
		DefinitionRef: request.GetDefinitionRef(), DefinitionVersion: request.GetDefinitionVersion(),
		IdempotencyKey: request.GetIdempotencyKey(), CanonicalInputs: append([]byte(nil), request.GetCanonicalInputs()...),
		MinCatalogRevision: request.MinCatalogRevision,
	}
	if err := flowsemantic.ValidateRequest(ctx, result); err != nil {
		return flowsemantic.Request{}, err
	}
	return result, nil
}

func FromWireExecuteCatalogActionRequest(
	ctx context.Context,
	request *runtimev1.ExecuteFlowRequest,
) (flowsemantic.CatalogActionRequest, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.CatalogActionRequest{}, err
	}
	if request == nil || request.GetDefinitionRef() != "" ||
		request.GetDefinitionVersion() != "" || request.GetCatalogAction() == nil {
		return flowsemantic.CatalogActionRequest{}, &flowsemantic.Failure{
			Category:         commonsemantic.FailureInvalidRequest,
			InvalidComponent: commonsemantic.InvalidComponentCommandData,
		}
	}
	result := flowsemantic.CatalogActionRequest{
		IdempotencyKey:     request.GetIdempotencyKey(),
		CanonicalInputs:    append([]byte(nil), request.GetCanonicalInputs()...),
		MinCatalogRevision: request.MinCatalogRevision,
		CatalogAction: flowsemantic.CatalogActionBinding{
			ComponentRef: request.GetCatalogAction().GetComponentRef(),
			ActionRef:    request.GetCatalogAction().GetActionRef(),
		},
	}
	if err := flowsemantic.ValidateCatalogActionRequest(ctx, result); err != nil {
		return flowsemantic.CatalogActionRequest{}, err
	}
	return result, nil
}

func ToWirePreviewCatalogActionRequest(
	ctx context.Context,
	request flowsemantic.CatalogActionPreviewRequest,
) (*runtimev1.PreviewCatalogActionRequest, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateCatalogActionPreviewRequest(ctx, request); err != nil {
		return nil, err
	}
	mode, ok := toWireCatalogActionPreviewMode(request.Mode)
	if !ok {
		return nil, invalidPlatformWire()
	}
	return &runtimev1.PreviewCatalogActionRequest{
		Mode:               mode,
		CanonicalInputs:    append([]byte(nil), request.CanonicalInputs...),
		RecordId:           request.RecordID,
		MinCatalogRevision: request.MinCatalogRevision,
		CatalogAction: &runtimev1.CatalogActionBinding{
			ComponentRef: request.CatalogAction.ComponentRef,
			ActionRef:    request.CatalogAction.ActionRef,
		},
	}, nil
}

func FromWirePreviewCatalogActionRequest(
	ctx context.Context,
	request *runtimev1.PreviewCatalogActionRequest,
) (flowsemantic.CatalogActionPreviewRequest, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.CatalogActionPreviewRequest{}, err
	}
	if request == nil || request.GetCatalogAction() == nil {
		return flowsemantic.CatalogActionPreviewRequest{}, invalidPlatformWire()
	}
	mode, ok := fromWireCatalogActionPreviewMode(request.GetMode())
	if !ok {
		return flowsemantic.CatalogActionPreviewRequest{}, invalidPlatformWire()
	}
	result := flowsemantic.CatalogActionPreviewRequest{
		Mode:               mode,
		CanonicalInputs:    append([]byte(nil), request.GetCanonicalInputs()...),
		RecordID:           request.GetRecordId(),
		MinCatalogRevision: request.MinCatalogRevision,
		CatalogAction: flowsemantic.CatalogActionBinding{
			ComponentRef: request.GetCatalogAction().GetComponentRef(),
			ActionRef:    request.GetCatalogAction().GetActionRef(),
		},
	}
	if err := flowsemantic.ValidateCatalogActionPreviewRequest(ctx, result); err != nil {
		return flowsemantic.CatalogActionPreviewRequest{}, err
	}
	return result, nil
}

func ToWirePreviewCatalogActionResponse(
	request flowsemantic.CatalogActionPreviewRequest,
	response flowsemantic.CatalogActionPreviewResponse,
) (*runtimev1.PreviewCatalogActionResponse, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateCatalogActionPreviewResponse(request, response); err != nil {
		return nil, err
	}
	return &runtimev1.PreviewCatalogActionResponse{
		CanonicalResult: append([]byte(nil), response.CanonicalResult...),
		Receipts:        toWireReceipts(response.Receipts, platformCapability(flowsemantic.CapabilityName)),
	}, nil
}

func FromWirePreviewCatalogActionResponse(
	request flowsemantic.CatalogActionPreviewRequest,
	response *runtimev1.PreviewCatalogActionResponse,
) (flowsemantic.CatalogActionPreviewResponse, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.CatalogActionPreviewResponse{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return flowsemantic.CatalogActionPreviewResponse{}, incompatibleFailureFor(
			platformCapability(flowsemantic.CapabilityName),
		)
	}
	receipts, err := fromWireReceipts(
		response.GetReceipts(), platformCapability(flowsemantic.CapabilityName),
	)
	if err != nil {
		return flowsemantic.CatalogActionPreviewResponse{}, err
	}
	result := flowsemantic.CatalogActionPreviewResponse{
		CanonicalResult: append([]byte(nil), response.GetCanonicalResult()...),
		Receipts:        receipts,
	}
	if err := flowsemantic.ValidateCatalogActionPreviewResponse(request, result); err != nil {
		return flowsemantic.CatalogActionPreviewResponse{}, err
	}
	return result, nil
}

func toWireCatalogActionPreviewMode(
	mode flowsemantic.CatalogActionPreviewMode,
) (runtimev1.CatalogActionPreviewMode, bool) {
	switch mode {
	case flowsemantic.CatalogActionPreviewCreateRecords:
		return runtimev1.CatalogActionPreviewMode_CATALOG_ACTION_PREVIEW_MODE_CREATE_RECORDS, true
	case flowsemantic.CatalogActionPreviewOutputs:
		return runtimev1.CatalogActionPreviewMode_CATALOG_ACTION_PREVIEW_MODE_OUTPUTS, true
	default:
		return runtimev1.CatalogActionPreviewMode_CATALOG_ACTION_PREVIEW_MODE_UNSPECIFIED, false
	}
}

func fromWireCatalogActionPreviewMode(
	mode runtimev1.CatalogActionPreviewMode,
) (flowsemantic.CatalogActionPreviewMode, bool) {
	switch mode {
	case runtimev1.CatalogActionPreviewMode_CATALOG_ACTION_PREVIEW_MODE_CREATE_RECORDS:
		return flowsemantic.CatalogActionPreviewCreateRecords, true
	case runtimev1.CatalogActionPreviewMode_CATALOG_ACTION_PREVIEW_MODE_OUTPUTS:
		return flowsemantic.CatalogActionPreviewOutputs, true
	default:
		return "", false
	}
}

func ToWireExecuteFlowResponse(response flowsemantic.Response) (*runtimev1.ExecuteFlowResponse, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateResponse(response); err != nil {
		return nil, err
	}
	return &runtimev1.ExecuteFlowResponse{
		ExecutionId: response.ExecutionID, CanonicalOutputs: append([]byte(nil), response.CanonicalOutputs...),
		Receipts: toWireReceipts(response.Receipts, platformCapability(flowsemantic.CapabilityName)),
	}, nil
}

func FromWireExecuteFlowResponse(response *runtimev1.ExecuteFlowResponse) (flowsemantic.Response, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.Response{}, err
	}
	if response == nil || response.GetReceipts() == nil || len(response.GetErrors()) != 0 {
		return flowsemantic.Response{}, incompatibleFailureFor(platformCapability(flowsemantic.CapabilityName))
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(flowsemantic.CapabilityName))
	if err != nil {
		return flowsemantic.Response{}, err
	}
	result := flowsemantic.Response{
		ExecutionID: response.GetExecutionId(), CanonicalOutputs: append([]byte(nil), response.GetCanonicalOutputs()...),
		Receipts: receipts,
	}
	if err := flowsemantic.ValidateResponse(result); err != nil {
		return flowsemantic.Response{}, err
	}
	return result, nil
}

func ToWireExecuteFlowResponseV2(response flowsemantic.ResponseV2) (*runtimev1.ExecuteFlowResponse, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := flowsemantic.ValidateResponseV2(response); err != nil {
		return nil, err
	}
	return &runtimev1.ExecuteFlowResponse{
		ExecutionId: response.ExecutionID, CanonicalOutputs: append([]byte(nil), response.CanonicalOutputs...),
		Errors:   toWireFlowExecutionErrors(response.Errors),
		Receipts: toWireReceipts(response.Receipts, platformCapability(flowsemantic.CapabilityName)),
	}, nil
}

func FromWireExecuteFlowResponseV2(response *runtimev1.ExecuteFlowResponse) (flowsemantic.ResponseV2, error) {
	if err := requirePlatformSemanticShape(flowsemantic.CapabilityName); err != nil {
		return flowsemantic.ResponseV2{}, err
	}
	if response == nil || response.GetReceipts() == nil ||
		len(response.GetErrors()) > flowsemantic.MaxExecutionErrors {
		return flowsemantic.ResponseV2{}, incompatibleFailureFor(platformCapability(flowsemantic.CapabilityName))
	}
	for _, executionError := range response.GetErrors() {
		if executionError == nil ||
			len(executionError.GetFields()) > flowsemantic.MaxFieldsPerExecutionError {
			return flowsemantic.ResponseV2{}, incompatibleFailureFor(platformCapability(flowsemantic.CapabilityName))
		}
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(flowsemantic.CapabilityName))
	if err != nil {
		return flowsemantic.ResponseV2{}, err
	}
	result := flowsemantic.ResponseV2{
		ExecutionID: response.GetExecutionId(), CanonicalOutputs: append([]byte(nil), response.GetCanonicalOutputs()...),
		Errors: fromWireFlowExecutionErrors(response.GetErrors()), Receipts: receipts,
	}
	if err := flowsemantic.ValidateResponseV2(result); err != nil {
		return flowsemantic.ResponseV2{}, err
	}
	return result, nil
}

func toWireFlowExecutionErrors(errors []flowsemantic.ExecutionError) []*runtimev1.FlowExecutionError {
	if len(errors) == 0 {
		return nil
	}
	result := make([]*runtimev1.FlowExecutionError, 0, len(errors))
	for _, executionError := range errors {
		result = append(result, &runtimev1.FlowExecutionError{
			Code: executionError.Code, Message: executionError.Message,
			Fields: append([]string(nil), executionError.Fields...),
		})
	}
	return result
}

func fromWireFlowExecutionErrors(errors []*runtimev1.FlowExecutionError) []flowsemantic.ExecutionError {
	if len(errors) == 0 {
		return nil
	}
	result := make([]flowsemantic.ExecutionError, 0, len(errors))
	for _, executionError := range errors {
		result = append(result, flowsemantic.ExecutionError{
			Code: executionError.GetCode(), Message: executionError.GetMessage(),
			Fields: append([]string(nil), executionError.GetFields()...),
		})
	}
	return result
}

func ToWireReadReportRequest(ctx context.Context, request reportsemantic.Request) (*runtimev1.ReadReportRequest, error) {
	if err := requirePlatformSemanticShape(reportsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := reportsemantic.ValidateRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.ReadReportRequest{
		ReportId: request.ReportID, CanonicalFilters: append([]byte(nil), request.CanonicalFilters...),
		Limit: request.Limit, Offset: request.Offset, MinCatalogRevision: request.MinCatalogRevision,
	}, nil
}

func FromWireReadReportRequest(ctx context.Context, request *runtimev1.ReadReportRequest) (reportsemantic.Request, error) {
	if err := requirePlatformSemanticShape(reportsemantic.CapabilityName); err != nil {
		return reportsemantic.Request{}, err
	}
	if request == nil {
		return reportsemantic.Request{}, invalidPlatformWire()
	}
	result := reportsemantic.Request{
		ReportID: request.GetReportId(), CanonicalFilters: append([]byte(nil), request.GetCanonicalFilters()...),
		Limit: request.GetLimit(), Offset: request.GetOffset(), MinCatalogRevision: request.MinCatalogRevision,
	}
	if err := reportsemantic.ValidateRequest(ctx, result); err != nil {
		return reportsemantic.Request{}, err
	}
	return result, nil
}

func ToWireReadReportResponse(response reportsemantic.Response) (*runtimev1.ReadReportResponse, error) {
	if err := requirePlatformSemanticShape(reportsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := reportsemantic.ValidateResponse(response); err != nil {
		return nil, err
	}
	return &runtimev1.ReadReportResponse{
		CanonicalResult: append([]byte(nil), response.CanonicalResult...),
		Receipts:        toWireReceipts(response.Receipts, platformCapability(reportsemantic.CapabilityName)),
	}, nil
}

func FromWireReadReportResponse(response *runtimev1.ReadReportResponse) (reportsemantic.Response, error) {
	if err := requirePlatformSemanticShape(reportsemantic.CapabilityName); err != nil {
		return reportsemantic.Response{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return reportsemantic.Response{}, incompatibleFailureFor(platformCapability(reportsemantic.CapabilityName))
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(reportsemantic.CapabilityName))
	if err != nil {
		return reportsemantic.Response{}, err
	}
	result := reportsemantic.Response{
		CanonicalResult: append([]byte(nil), response.GetCanonicalResult()...), Receipts: receipts,
	}
	if err := reportsemantic.ValidateResponse(result); err != nil {
		return reportsemantic.Response{}, err
	}
	return result, nil
}

func ToWireAcceptCommandRequest(ctx context.Context, request commandsemantic.Request) (*runtimev1.AcceptCommandRequest, error) {
	if err := requirePlatformSemanticShape(commandsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := commandsemantic.ValidateRequest(ctx, request); err != nil {
		return nil, err
	}
	return &runtimev1.AcceptCommandRequest{
		CommandId: request.CommandID, IdempotencyKey: request.IdempotencyKey, CommandKind: request.CommandKind,
		PartitionKey: request.PartitionKey, PayloadFormatVersion: request.PayloadFormatVersion,
		Payload: append([]byte(nil), request.Payload...), PayloadDigest: request.PayloadDigest,
		MinCatalogRevision: request.MinCatalogRevision,
	}, nil
}

func FromWireAcceptCommandRequest(ctx context.Context, request *runtimev1.AcceptCommandRequest) (commandsemantic.Request, error) {
	if err := requirePlatformSemanticShape(commandsemantic.CapabilityName); err != nil {
		return commandsemantic.Request{}, err
	}
	if request == nil {
		return commandsemantic.Request{}, invalidPlatformWire()
	}
	result := commandsemantic.Request{
		CommandID: request.GetCommandId(), IdempotencyKey: request.GetIdempotencyKey(),
		CommandKind: request.GetCommandKind(), PartitionKey: request.GetPartitionKey(),
		PayloadFormatVersion: request.GetPayloadFormatVersion(), Payload: append([]byte(nil), request.GetPayload()...),
		PayloadDigest: request.GetPayloadDigest(), MinCatalogRevision: request.MinCatalogRevision,
	}
	if err := commandsemantic.ValidateRequest(ctx, result); err != nil {
		return commandsemantic.Request{}, err
	}
	return result, nil
}

func ToWireAcceptCommandResponse(request commandsemantic.Request, response commandsemantic.Response) (*runtimev1.AcceptCommandResponse, error) {
	if err := requirePlatformSemanticShape(commandsemantic.CapabilityName); err != nil {
		return nil, err
	}
	if err := commandsemantic.ValidateResponse(request, response); err != nil {
		return nil, err
	}
	return &runtimev1.AcceptCommandResponse{
		CommandId: response.CommandID, Duplicate: response.Duplicate,
		Receipts: toWireReceipts(response.Receipts, platformCapability(commandsemantic.CapabilityName)),
	}, nil
}

func FromWireAcceptCommandResponse(request commandsemantic.Request, response *runtimev1.AcceptCommandResponse) (commandsemantic.Response, error) {
	if err := requirePlatformSemanticShape(commandsemantic.CapabilityName); err != nil {
		return commandsemantic.Response{}, err
	}
	if response == nil || response.GetReceipts() == nil {
		return commandsemantic.Response{}, incompatibleFailureFor(platformCapability(commandsemantic.CapabilityName))
	}
	receipts, err := fromWireReceipts(response.GetReceipts(), platformCapability(commandsemantic.CapabilityName))
	if err != nil {
		return commandsemantic.Response{}, err
	}
	result := commandsemantic.Response{
		CommandID: response.GetCommandId(), Duplicate: response.GetDuplicate(), Receipts: receipts,
	}
	if err := commandsemantic.ValidateResponse(request, result); err != nil {
		return commandsemantic.Response{}, err
	}
	return result, nil
}