package services

import (
	"context"
	"errors"
	"testing"

	appErrors "github.com/nexuscrm/kernel/pkg/errors"
	"github.com/nexuscrm/kernel/pkg/ports"
	"github.com/nexuscrm/metadata"
	"github.com/nexuscrm/records"
	"github.com/nexuscrm/shared/pkg/contract"
	sharedErrors "github.com/nexuscrm/shared/pkg/errors"
	"github.com/nexuscrm/shared/pkg/models"
	"github.com/nexuscrm/shared/pkg/queryspec"
)

func TestContractDepsBundlesInjectedNeutralSurfaces(t *testing.T) {
	records := &fakeContractRecords{}
	recordMutationCoordinator := &fakeContractRecordMutationCoordinator{}
	recycleBin := &fakeContractRecycleBin{}
	auditLog := &fakeContractAuditLog{}
	query := &fakeContractQuery{}
	metadata := &fakeContractMetadata{}
	metadataAuthoring := &fakeContractMetadataAuthoring{}
	metadataDeploy := &fakeContractMetadataDeploy{}
	applicationNavigation := &fakeContractApplicationNavigation{}
	metadataMaintenance := &fakeContractMetadataMaintenance{}
	rollupMaintenance := &fakeContractRollupMaintenance{}
	bulkJobs := &fakeContractBulkJobs{}
	bulkIngest := &fakeContractBulkIngest{}
	reports := &fakeContractReports{}
	folderAccess := &fakeContractFolderAccess{}
	resourceAccess := &fakeContractResourceAccess{}
	userSessions := &fakeContractUserSessions{}
	policy := &fakeContractPolicy{}
	notifications := &fakeContractNotifications{}
	permissionAdmin := &fakeContractPermissionAdmin{}
	connectorSyncStatus := &fakeContractConnectorSyncStatus{}
	connectorWebhookSecrets := &fakeContractConnectorWebhookSecrets{}
	flow := &fakeContractFlowExecutor{}
	flowCatalog := &fakeContractFlowCatalog{}
	flowInterviews := &fakeContractFlowInterviews{}
	flowAuthoring := &fakeContractFlowAuthoring{}
	approvals := &fakeContractApprovals{}
	standardActions := &fakeContractStandardActions{}

	sm := &ServiceManager{
		NeutralRecords:                   records,
		NeutralRecordMutationCoordinator: recordMutationCoordinator,
		NeutralRecycleBin:                recycleBin,
		NeutralAuditLog:                  auditLog,
		NeutralQuery:                     query,
		NeutralMetadata:                  metadata,
		NeutralMetadataAuthoring:         metadataAuthoring,
		NeutralMetadataDeploy:            metadataDeploy,
		NeutralApplicationNavigation:     applicationNavigation,
		NeutralMetadataMaintenance:       metadataMaintenance,
		NeutralRollupMaintenance:         rollupMaintenance,
		NeutralBulkJobs:                  bulkJobs,
		NeutralBulkIngest:                bulkIngest,
		NeutralReports:                   reports,
		NeutralFolderAccess:              folderAccess,
		NeutralResourceAccess:            resourceAccess,
		NeutralUserSessions:              userSessions,
		NeutralPolicy:                    policy,
		NeutralNotifications:             notifications,
		NeutralPermissionAdmin:           permissionAdmin,
		NeutralConnectorSyncStatus:       connectorSyncStatus,
		NeutralConnectorWebhookSecrets:   connectorWebhookSecrets,
		NeutralFlowExecutor:              flow,
		NeutralFlowCatalog:               flowCatalog,
		NeutralFlowInterviews:            flowInterviews,
		NeutralFlowAuthoring:             flowAuthoring,
		NeutralApprovals:                 approvals,
		NeutralStandardActions:           standardActions,
	}

	deps := sm.ContractDeps()
	if deps.Records != records {
		t.Fatal("ContractDeps().Records did not use injected neutral records")
	}
	if deps.RecordMutationCoordinator != recordMutationCoordinator {
		t.Fatal("ContractDeps().RecordMutationCoordinator did not use injected neutral record mutation coordinator")
	}
	if deps.RecycleBin != recycleBin {
		t.Fatal("ContractDeps().RecycleBin did not use injected neutral recycle-bin")
	}
	if deps.AuditLog != auditLog {
		t.Fatal("ContractDeps().AuditLog did not use injected neutral audit-log")
	}
	if deps.Query != query {
		t.Fatal("ContractDeps().Query did not use injected neutral query")
	}
	if deps.Metadata != metadata {
		t.Fatal("ContractDeps().Metadata did not use injected neutral metadata")
	}
	if deps.MetadataAuthoring != metadataAuthoring {
		t.Fatal("ContractDeps().MetadataAuthoring did not use injected neutral metadata authoring")
	}
	if deps.MetadataDeploy != metadataDeploy {
		t.Fatal("ContractDeps().MetadataDeploy did not use injected neutral metadata deploy")
	}
	if deps.ApplicationNavigation != applicationNavigation {
		t.Fatal("ContractDeps().ApplicationNavigation did not use injected neutral application navigation")
	}
	if deps.MetadataMaintenance != metadataMaintenance {
		t.Fatal("ContractDeps().MetadataMaintenance did not use injected neutral metadata maintenance")
	}
	if deps.RollupMaintenance != rollupMaintenance {
		t.Fatal("ContractDeps().RollupMaintenance did not use injected neutral rollup maintenance")
	}
	if deps.BulkJobs != bulkJobs {
		t.Fatal("ContractDeps().BulkJobs did not use injected neutral bulk jobs")
	}
	if deps.BulkIngest != bulkIngest {
		t.Fatal("ContractDeps().BulkIngest did not use injected neutral bulk ingest")
	}
	if deps.Reports != reports {
		t.Fatal("ContractDeps().Reports did not use injected neutral reports")
	}
	if deps.FolderAccess != folderAccess {
		t.Fatal("ContractDeps().FolderAccess did not use injected neutral folder access")
	}
	if deps.ResourceAccess != resourceAccess {
		t.Fatal("ContractDeps().ResourceAccess did not use injected neutral resource access")
	}
	if deps.UserSessions != userSessions {
		t.Fatal("ContractDeps().UserSessions did not use injected neutral user sessions")
	}
	if deps.Policy != policy {
		t.Fatal("ContractDeps().Policy did not use injected neutral policy")
	}
	if deps.Notifications != notifications {
		t.Fatal("ContractDeps().Notifications did not use injected neutral notifications")
	}
	if deps.PermissionAdmin != permissionAdmin {
		t.Fatal("ContractDeps().PermissionAdmin did not use injected neutral permission admin")
	}
	if deps.ConnectorSyncStatus != connectorSyncStatus {
		t.Fatal("ContractDeps().ConnectorSyncStatus did not use injected neutral connector sync status")
	}
	if deps.ConnectorWebhookSecrets != connectorWebhookSecrets {
		t.Fatal("ContractDeps().ConnectorWebhookSecrets did not use injected neutral connector webhook secrets")
	}
	if deps.FlowExecutor != flow {
		t.Fatal("ContractDeps().FlowExecutor did not use injected neutral flow executor")
	}
	if deps.FlowCatalog != flowCatalog {
		t.Fatal("ContractDeps().FlowCatalog did not use injected neutral flow catalog")
	}
	if deps.FlowInterviews != flowInterviews {
		t.Fatal("ContractDeps().FlowInterviews did not use injected neutral flow interviews")
	}
	if deps.FlowAuthoring != flowAuthoring {
		t.Fatal("ContractDeps().FlowAuthoring did not use injected neutral flow authoring")
	}
	if deps.Approvals != approvals {
		t.Fatal("ContractDeps().Approvals did not use injected neutral approvals")
	}
	if deps.StandardActions != standardActions {
		t.Fatal("ContractDeps().StandardActions did not use injected neutral standard actions")
	}
}

func TestContractDepsNilSafeWhenSurfacesMissing(t *testing.T) {
	var nilManager *ServiceManager
	assertEmptyContractDeps(t, nilManager.ContractDeps())
	assertEmptyContractDeps(t, (&ServiceManager{}).ContractDeps())
}

func assertEmptyContractDeps(t *testing.T, deps contract.Deps) {
	t.Helper()
	if deps.Records != nil ||
		deps.RecordMutationCoordinator != nil ||
		deps.RecycleBin != nil ||
		deps.AuditLog != nil ||
		deps.Query != nil ||
		deps.Metadata != nil ||
		deps.MetadataAuthoring != nil ||
		deps.MetadataDeploy != nil ||
		deps.ApplicationNavigation != nil ||
		deps.MetadataMaintenance != nil ||
		deps.RollupMaintenance != nil ||
		deps.BulkJobs != nil ||
		deps.BulkIngest != nil ||
		deps.Reports != nil ||
		deps.FolderAccess != nil ||
		deps.ResourceAccess != nil ||
		deps.UserSessions != nil ||
		deps.Policy != nil ||
		deps.Notifications != nil ||
		deps.PermissionAdmin != nil ||
		deps.ConnectorSyncStatus != nil ||
		deps.ConnectorWebhookSecrets != nil ||
		deps.SearchScope != nil ||
		deps.Activity != nil ||
		deps.Files != nil || deps.RecordAttachmentMetadata != nil ||
		deps.FlowExecutor != nil ||
		deps.FlowCatalog != nil ||
		deps.FlowInterviews != nil ||
		deps.FlowAuthoring != nil ||
		deps.Approvals != nil ||
		deps.StandardActions != nil {
		t.Fatalf("ContractDeps() = %+v, want all nil", deps)
	}
}

func TestFlowAuthoringErrorPreservesInternalBeforeFLS(t *testing.T) {
	err := appErrors.NewInternalError(
		"rollback failed",
		appErrors.NewFLSDeniedErrorForFields([]string{"VersionNumber"}),
	)
	got := flowAuthoringError(err)
	if !appErrors.IsInternal(got) {
		t.Fatalf("flowAuthoringError() = %T %v, want internal classification", got, got)
	}
	var flowErr *contract.FlowAuthoringError
	if errors.As(got, &flowErr) {
		t.Fatalf("flowAuthoringError() returned FlowAuthoringError %+v, want internal preserved", flowErr)
	}
}

func TestFlowAuthoringErrorTranslatesBackendNotFoundToNeutralWireError(t *testing.T) {
	err := appErrors.NewNotFoundError("Flow", "missing")
	got := flowAuthoringError(err)

	var domainErr *sharedErrors.DomainWireError
	if !errors.As(got, &domainErr) {
		t.Fatalf("flowAuthoringError() = %T %v, want neutral DomainWireError", got, got)
	}
	if domainErr.Kind != sharedErrors.WireNotFound {
		t.Fatalf("DomainWireError.Kind = %q, want %q", domainErr.Kind, sharedErrors.WireNotFound)
	}
	if domainErr.Message != "Flow with ID 'missing' not found" {
		t.Fatalf("DomainWireError.Message = %q", domainErr.Message)
	}
	if !errors.Is(domainErr.Cause, err) {
		t.Fatalf("DomainWireError.Cause = %v, want original backend not-found", domainErr.Cause)
	}
}

func TestCreateFlowVersionRequiresProcessTypeForAutoCreatedDefinition(t *testing.T) {
	sm := &ServiceManager{Metadata: metadata.NewMetadataService(nil, nil, nil)}

	_, err := sm.CreateFlowVersion(context.Background(), contract.FlowVersionWrite{
		MasterLabel: "New Flow",
		Status:      "Draft",
		MetadataRaw: []byte(`{"label":"New Flow"}`),
	})
	if err == nil {
		t.Fatal("CreateFlowVersion() error = nil, want missing ProcessType error")
	}

	var domainErr *sharedErrors.DomainWireError
	if !errors.As(err, &domainErr) {
		t.Fatalf("CreateFlowVersion() error = %T %v, want DomainWireError", err, err)
	}
	if domainErr.Kind != sharedErrors.WireInvalidField {
		t.Fatalf("DomainWireError.Kind = %q, want %q", domainErr.Kind, sharedErrors.WireInvalidField)
	}
	if domainErr.Message != "FlowVersion ProcessType is required when creating a FlowDefinition" {
		t.Fatalf("DomainWireError.Message = %q", domainErr.Message)
	}
}

func TestRecordLifecycleContractUsesPersistenceRegistrar(t *testing.T) {
	sm := &ServiceManager{Persistence: &records.PersistenceService{}}

	if got := sm.RecordLifecycleContract(); got != sm.Persistence {
		t.Fatal("RecordLifecycleContract() did not return the concrete PersistenceService registrar")
	}
}

func TestRecordLifecycleContractNilSafe(t *testing.T) {
	var nilManager *ServiceManager
	if got := nilManager.RecordLifecycleContract(); got != nil {
		t.Fatalf("nil RecordLifecycleContract() = %v, want nil", got)
	}
	if got := (&ServiceManager{}).RecordLifecycleContract(); got != nil {
		t.Fatalf("empty RecordLifecycleContract() = %v, want nil", got)
	}
}

func TestRecordWriteValidationContractUsesPersistenceRegistrar(t *testing.T) {
	sm := &ServiceManager{Persistence: &records.PersistenceService{}}

	if got := sm.RecordWriteValidationContract(); got != sm.Persistence {
		t.Fatal("RecordWriteValidationContract() did not return the concrete PersistenceService registrar")
	}
}

func TestRecordWriteValidationContractNilSafe(t *testing.T) {
	var nilManager *ServiceManager
	if got := nilManager.RecordWriteValidationContract(); got != nil {
		t.Fatalf("nil RecordWriteValidationContract() = %v, want nil", got)
	}
	if got := (&ServiceManager{}).RecordWriteValidationContract(); got != nil {
		t.Fatalf("empty RecordWriteValidationContract() = %v, want nil", got)
	}
}

type fakeContractRecords struct{}

func (*fakeContractRecords) Insert(context.Context, string, contract.Record, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) Retrieve(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) RetrieveMany(context.Context, string, []string, *models.UserSession) (map[string]contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) Update(context.Context, string, string, contract.Record, *models.UserSession) error {
	return nil
}

type fakeContractRecordMutationCoordinator struct{}

func (*fakeContractRecordMutationCoordinator) RunInPessimisticTransaction(ctx context.Context, fn func(context.Context) error) error {
	return fn(ctx)
}

func (*fakeContractRecordMutationCoordinator) RequiresSourceAwareTransaction(string) bool {
	return false
}

func (*fakeContractRecords) Delete(context.Context, string, string, *models.UserSession) error {
	return nil
}
func (*fakeContractRecords) UpsertByExternalID(context.Context, string, string, string, contract.Record, *models.UserSession) (contract.Record, bool, error) {
	return nil, false, nil
}
func (*fakeContractRecords) RetrieveByField(context.Context, string, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) CreateRecords(context.Context, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}
func (*fakeContractRecords) UpdateRecords(context.Context, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}
func (*fakeContractRecords) DeleteRecords(context.Context, []string, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}
func (*fakeContractRecords) UpsertRecords(context.Context, string, string, []contract.Record, bool, *models.UserSession) ([]contract.RecordMutationResult, error) {
	return nil, nil
}
func (*fakeContractRecords) RetrieveRecords(context.Context, string, []string, []string, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) CreateTree(context.Context, string, []contract.Record, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}
func (*fakeContractRecords) ObjectTypeForID(context.Context, string) (string, error) {
	return "", nil
}

type fakeContractQuery struct{}

type fakeContractRecycleBin struct{}

func (*fakeContractRecycleBin) ListRecycleBin(context.Context, *models.UserSession, contract.RecycleBinScope) (*contract.RecycleBinListResult, error) {
	return nil, nil
}

func (*fakeContractRecycleBin) RestoreRecycleBinRecord(context.Context, string, *models.UserSession) error {
	return nil
}

func (*fakeContractRecycleBin) PurgeRecycleBinRecord(context.Context, string, *models.UserSession) error {
	return nil
}

type fakeContractAuditLog struct{}

func (*fakeContractAuditLog) QueryAuditLog(context.Context, contract.AuditLogQueryRequest, *models.UserSession) (*contract.AuditLogQueryResult, error) {
	return nil, nil
}

func (*fakeContractQuery) Query(context.Context, queryspec.QuerySpec, *models.UserSession) (*contract.QueryResult, error) {
	return nil, nil
}
func (*fakeContractQuery) SearchWithSpec(context.Context, queryspec.SearchSpec, *models.UserSession) ([]contract.Record, error) {
	return nil, nil
}
func (*fakeContractQuery) GlobalSearchWithSpec(context.Context, queryspec.GlobalSearchSpec, *models.UserSession) ([]contract.SearchResult, error) {
	return nil, nil
}
func (*fakeContractQuery) QueryHistory(context.Context, contract.HistoryQueryRequest, *models.UserSession) (*contract.HistoryQueryResult, error) {
	return nil, nil
}

type fakeContractReports struct{}

func (*fakeContractReports) GetReportMetadata(context.Context, string, *models.UserSession) (*models.ReportDefinition, error) {
	return nil, nil
}

func (*fakeContractReports) RunReportDefinition(context.Context, *models.ReportDefinition, *models.UserSession, map[string]interface{}, int) (*models.ReportResult, error) {
	return nil, nil
}

type fakeContractFolderAccess struct{}

func (*fakeContractFolderAccess) CheckFolderAccess(context.Context, *models.UserSession, string, contract.FolderAccessLevel) bool {
	return false
}

type fakeContractResourceAccess struct{}

func (*fakeContractResourceAccess) ListVisibleResourceIDs(context.Context, *models.UserSession, contract.ResourceVisibilityRequest) ([]string, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) ListResourceAccessGrants(context.Context, *models.UserSession, contract.ResourceAccessListRequest) ([]contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) GetResourceAccessGrant(context.Context, *models.UserSession, contract.ResourceAccessGetRequest) (*contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) CreateResourceAccessGrant(context.Context, *models.UserSession, contract.ResourceAccessCreateRequest) (*contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) EnsureResourceAccessGrant(context.Context, *models.UserSession, contract.ResourceAccessEnsureRequest) (*contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) ReplaceResourceAccessGrants(context.Context, *models.UserSession, contract.ResourceAccessReplaceRequest) ([]contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) UpdateResourceAccessGrant(context.Context, *models.UserSession, contract.ResourceAccessUpdateRequest) (*contract.ResourceAccessGrant, error) {
	return nil, nil
}

func (*fakeContractResourceAccess) DeleteResourceAccessGrant(context.Context, *models.UserSession, contract.ResourceAccessDeleteRequest) error {
	return nil
}

func (*fakeContractResourceAccess) DeleteResourceAccessGrantsByPrincipalType(context.Context, *models.UserSession, contract.ResourceAccessDeleteByPrincipalTypeRequest) error {
	return nil
}

func (*fakeContractResourceAccess) TransferResourceOwnership(context.Context, *models.UserSession, contract.ResourceOwnershipTransferRequest) error {
	return nil
}

type fakeContractUserSessions struct{}

func (*fakeContractUserSessions) LoadUserSession(context.Context, string) (*models.UserSession, error) {
	return nil, nil
}

type fakeContractMetadata struct{}

func (*fakeContractMetadata) Describe(context.Context, string) (*models.ObjectMetadata, error) {
	return nil, nil
}
func (*fakeContractMetadata) ListObjects(context.Context) ([]models.ObjectMetadata, error) {
	return nil, nil
}
func (*fakeContractMetadata) Relationships(context.Context, string) ([]*models.Relationship, error) {
	return nil, nil
}
func (*fakeContractMetadata) ChildRelationships(context.Context, string) ([]*models.ObjectMetadata, error) {
	return nil, nil
}
func (*fakeContractMetadata) KeyPrefix(context.Context, string) (string, bool) {
	return "", false
}
func (*fakeContractMetadata) ResolveLayout(context.Context, string, *models.UserSession, string) (*models.PageLayout, error) {
	return nil, nil
}
func (*fakeContractMetadata) ResolvePicklistValuesForRecordType(context.Context, string, string, string) (*models.ScopedPicklistValueSet, error) {
	return nil, nil
}
func (*fakeContractMetadata) ResolveRelatedListResolution(context.Context, string, string) (*contract.RelatedListResolution, bool) {
	return nil, false
}
func (*fakeContractMetadata) Actions(context.Context, string) ([]*models.ActionMetadata, error) {
	return nil, nil
}
func (*fakeContractMetadata) ActionByID(context.Context, string) (*models.ActionMetadata, error) {
	return nil, nil
}

type fakeContractNotifications struct{}

func (*fakeContractNotifications) SendEmail(context.Context, *contract.OutboundEmailMessage) (*contract.OutboundEmailResult, error) {
	return nil, nil
}

func (*fakeContractNotifications) FrontendBaseURL(context.Context) string {
	return ""
}

type fakeEmailSender struct{}

func (fakeEmailSender) Send(context.Context, *ports.EmailMessage) (*ports.EmailSendResult, error) {
	return &ports.EmailSendResult{}, nil
}

type fakeContractMetadataAuthoring struct{}

func (*fakeContractMetadataAuthoring) ListSchemasForAuthoring(context.Context) []*models.ObjectMetadata {
	return nil
}

func (*fakeContractMetadataAuthoring) GetEffectiveSchemaForAuthoring(context.Context, string, *models.UserSession) *models.ObjectMetadata {
	return nil
}

func (*fakeContractMetadataAuthoring) SharingParentRelationship(context.Context, string) *models.Relationship {
	return nil
}

func (*fakeContractMetadataAuthoring) CreateSchema(context.Context, contract.MetadataSchemaCreateRequest) (*models.ObjectMetadata, error) {
	return nil, nil
}

func (*fakeContractMetadataAuthoring) UpdateSchema(context.Context, string, *models.ObjectMetadata) error {
	return nil
}

func (*fakeContractMetadataAuthoring) DeleteSchema(context.Context, string) error {
	return nil
}

func (*fakeContractMetadataAuthoring) RefreshAuthoringMetadataCache(context.Context) error {
	return nil
}

func (*fakeContractMetadataAuthoring) CreateField(context.Context, string, *models.FieldMetadata) error {
	return nil
}

func (*fakeContractMetadataAuthoring) BatchCreateFields(context.Context, string, []models.FieldMetadata) ([]*models.FieldMetadata, error) {
	return nil, nil
}

func (*fakeContractMetadataAuthoring) UpdateField(context.Context, string, string, *models.FieldMetadata, contract.FieldPatchPresence) error {
	return nil
}

func (*fakeContractMetadataAuthoring) DeleteField(context.Context, string, string) error {
	return nil
}

func (*fakeContractMetadataAuthoring) ListValidationRules(context.Context, string) []models.ValidationRule {
	return nil
}

func (*fakeContractMetadataAuthoring) CreateValidationRule(context.Context, *models.ValidationRule) error {
	return nil
}

func (*fakeContractMetadataAuthoring) UpdateValidationRule(context.Context, string, *models.ValidationRule) error {
	return nil
}

func (*fakeContractMetadataAuthoring) DeleteValidationRule(context.Context, string) error {
	return nil
}
func (*fakeContractMetadataAuthoring) CreateAction(context.Context, *models.ActionMetadata) error {
	return nil
}

func (*fakeContractMetadataAuthoring) CreateLayoutAssignment(context.Context, *models.LayoutAssignment) error {
	return nil
}

type fakeContractMetadataDeploy struct{}

func (*fakeContractMetadataDeploy) StartMetadataDeploy(context.Context) (string, error) {
	return "", nil
}

func (*fakeContractMetadataDeploy) CompleteMetadataDeploy(context.Context, string, contract.MetadataDeployResult) error {
	return nil
}

func (*fakeContractMetadataDeploy) GetMetadataDeployResult(context.Context, string) (*contract.MetadataDeployResult, bool, error) {
	return nil, false, nil
}

func (*fakeContractMetadataDeploy) ApplyMetadataDeployRecord(context.Context, contract.MetadataDeployRecordRequest, *models.UserSession) (*contract.MetadataDeployRecordResult, error) {
	return nil, nil
}

type fakeContractApplicationNavigation struct{}

func (*fakeContractApplicationNavigation) ListApplications(context.Context) ([]*models.AppConfig, error) {
	return nil, nil
}

func (*fakeContractApplicationNavigation) ListVisibleApplications(context.Context, *models.UserSession) ([]*models.AppConfig, error) {
	return nil, nil
}

func (*fakeContractApplicationNavigation) GetApplication(context.Context, string) (*models.AppConfig, error) {
	return nil, nil
}

func (*fakeContractApplicationNavigation) CreateApplication(context.Context, *models.AppConfig) error {
	return nil
}

func (*fakeContractApplicationNavigation) UpdateApplication(context.Context, string, *models.AppConfig, contract.ApplicationPatchPresence) error {
	return nil
}

func (*fakeContractApplicationNavigation) DeleteApplication(context.Context, string) error {
	return nil
}

type fakeContractMetadataMaintenance struct{}

func (*fakeContractMetadataMaintenance) RefreshAutoNumberMetadata(context.Context) (*contract.AutoNumberMetadataRefreshResult, error) {
	return nil, nil
}

func (*fakeContractMetadataMaintenance) FormulaViewStatus(context.Context, string) (*contract.FormulaViewStatusResult, error) {
	return nil, nil
}

func (*fakeContractMetadataMaintenance) PreviewFormulaViewDDL(context.Context, string) (*contract.FormulaViewDDLResult, error) {
	return nil, nil
}

func (*fakeContractMetadataMaintenance) RebuildFormulaView(context.Context, string) (*contract.FormulaViewRebuildResult, error) {
	return nil, nil
}

func (*fakeContractMetadataMaintenance) RebuildAllFormulaViews(context.Context) (*contract.FormulaViewRebuildAllResult, error) {
	return nil, nil
}

func (*fakeContractMetadataMaintenance) ValidateFormulaView(context.Context, contract.FormulaViewValidationRequest) (*contract.FormulaViewValidationResult, error) {
	return nil, nil
}

type fakeContractRollupMaintenance struct{}

func (*fakeContractRollupMaintenance) RecalculateRollups(context.Context, contract.RollupRecalculateRequest) (*contract.RollupRecalculateResult, error) {
	return nil, nil
}

type fakeContractBulkJobs struct{}

func (*fakeContractBulkJobs) CreateJob(context.Context, *models.BulkJob) error {
	return nil
}

func (*fakeContractBulkJobs) GetJob(context.Context, string) (*models.BulkJob, error) {
	return nil, nil
}

func (*fakeContractBulkJobs) UpdateJob(context.Context, *models.BulkJob) error {
	return nil
}

type fakeContractBulkIngest struct{}

func (*fakeContractBulkIngest) CreateIngestJob(context.Context, contract.BulkIngestCreateRequest, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*fakeContractBulkIngest) GetIngestJob(context.Context, string, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*fakeContractBulkIngest) CloseIngestJob(context.Context, string, models.BulkJobState, *models.UserSession) (*models.BulkJob, error) {
	return nil, nil
}

func (*fakeContractBulkIngest) UploadIngestData(context.Context, contract.BulkIngestUploadRequest, *models.UserSession) error {
	return nil
}

type fakeContractPolicy struct{}

func (*fakeContractPolicy) Access(context.Context, *models.UserSession, string, contract.AccessRequest) (*contract.EffectiveObjectAccess, error) {
	return nil, nil
}

func (*fakeContractPolicy) HasCapability(context.Context, *models.UserSession, contract.Capability) bool {
	return false
}

type fakeContractPermissionAdmin struct{}

func (*fakeContractPermissionAdmin) ListObjectPermissions(context.Context, *models.UserSession) ([]contract.ObjectAccessProjection, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) ListSystemPermissionCatalog(context.Context) ([]contract.CapabilityCatalogEntry, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) GetPermissionSetSystemGrants(context.Context, string) (map[string]bool, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) SavePermissionSetSystemGrants(context.Context, string, map[string]bool, *models.UserSession) error {
	return nil
}
func (*fakeContractPermissionAdmin) EffectivePermissions(context.Context, *models.UserSession, string) (*contract.EffectivePermissionsResult, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) ListRecordTypeCatalog(context.Context) ([]contract.PermissionRecordTypeCatalogEntry, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) GetPermissionSetRecordTypeGrants(context.Context, string) ([]contract.RecordTypeVisibilityGrant, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) SavePermissionSetRecordTypeGrants(context.Context, string, map[string]contract.PermissionRecordTypeGrantChange) error {
	return nil
}
func (*fakeContractPermissionAdmin) ListCustomPermissionCatalog(context.Context) ([]contract.CustomCapabilityCatalogEntry, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) GetPermissionSetCustomPermissionGrants(context.Context, string) ([]contract.CustomCapabilityGrant, error) {
	return nil, nil
}
func (*fakeContractPermissionAdmin) SavePermissionSetCustomPermissionGrants(context.Context, string, map[string]bool) error {
	return nil
}

type fakeContractConnectorSyncStatus struct{}

func (*fakeContractConnectorSyncStatus) GetConnectorSyncStatus(context.Context, *models.UserSession, string, string) (*contract.ConnectorSyncStatusResult, error) {
	return nil, nil
}

type fakeContractConnectorWebhookSecrets struct{}

func (*fakeContractConnectorWebhookSecrets) ListConnectorWebhookSecrets(context.Context, string) ([]contract.ConnectorWebhookSecret, error) {
	return nil, nil
}
func (*fakeContractConnectorWebhookSecrets) RotateConnectorWebhookSecret(context.Context, string, string) (*contract.ConnectorWebhookSecretRotation, error) {
	return nil, nil
}

type fakeContractFlowExecutor struct{}

func (*fakeContractFlowExecutor) ExecuteFlow(context.Context, string, map[string]any, *models.UserSession) (*contract.FlowExecutionResult, error) {
	return nil, nil
}
func (*fakeContractFlowExecutor) ResumeInterview(context.Context, string, *models.UserSession) error {
	return nil
}

type fakeContractFlowCatalog struct{}

func (*fakeContractFlowCatalog) ProtectedFlowNames(context.Context) ([]string, error) {
	return nil, nil
}

func (*fakeContractFlowCatalog) ListFlows(context.Context) ([]contract.FlowDescriptor, error) {
	return nil, nil
}

func (*fakeContractFlowCatalog) GetFlow(context.Context, string) (*contract.FlowDescriptor, error) {
	return nil, nil
}

func (*fakeContractFlowCatalog) GetFlowRevision(context.Context, string) (*contract.FlowRevisionDescriptor, error) {
	return nil, nil
}

type fakeContractFlowInterviews struct{}

func (*fakeContractFlowInterviews) ListFlowInterviews(context.Context, *models.UserSession) ([]contract.FlowInterviewRecord, error) {
	return nil, nil
}

func (*fakeContractFlowInterviews) GetFlowInterview(context.Context, string, *models.UserSession) (*contract.FlowInterviewRecord, error) {
	return nil, nil
}

func (*fakeContractFlowInterviews) DeleteFlowInterview(context.Context, string, *models.UserSession) error {
	return nil
}

type fakeContractFlowAuthoring struct{}

func (*fakeContractFlowAuthoring) ListFlowDefinitions(context.Context) ([]contract.FlowDefinitionRecord, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) GetFlowDefinition(context.Context, string) (*contract.FlowDefinitionRecord, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) CreateFlowDefinition(context.Context, contract.FlowDefinitionWrite) (*contract.FlowDefinitionCreateResult, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) PatchFlowDefinition(context.Context, string, contract.FlowAdminDefinitionPatchIntent) error {
	return nil
}

func (*fakeContractFlowAuthoring) DeleteFlowDefinition(context.Context, string) error {
	return nil
}

func (*fakeContractFlowAuthoring) ListFlowVersions(context.Context, string) ([]contract.FlowVersionRecord, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) GetFlowVersion(context.Context, string) (*contract.FlowVersionRecord, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) CreateFlowVersion(context.Context, contract.FlowVersionWrite) (*contract.FlowVersionCreateResult, error) {
	return nil, nil
}

func (*fakeContractFlowAuthoring) PatchFlowVersion(context.Context, string, contract.FlowAdminVersionPatchIntent) error {
	return nil
}

func (*fakeContractFlowAuthoring) DeleteFlowVersion(context.Context, string) error {
	return nil
}

func (*fakeContractFlowAuthoring) ActivateFlowVersion(context.Context, string) error {
	return nil
}

func (*fakeContractFlowAuthoring) DeactivateFlowVersion(context.Context, string) error {
	return nil
}

type fakeContractApprovals struct{}

func (*fakeContractApprovals) Submit(context.Context, contract.ApprovalSubmitRequest, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractApprovals) Approve(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractApprovals) Reject(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractApprovals) Recall(context.Context, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractApprovals) Reassign(context.Context, string, string, *models.UserSession) error {
	return nil
}
func (*fakeContractApprovals) ListPendingApprovals(context.Context, *models.UserSession) ([]contract.ApprovalPendingView, error) {
	return nil, nil
}
func (*fakeContractApprovals) GetLatestProcessInstance(context.Context, string, *models.UserSession) (*contract.ApprovalProcessInstanceSummary, error) {
	return nil, nil
}
func (*fakeContractApprovals) GetRecordApprovalStepDisplayMetadata(context.Context, string, *models.UserSession) ([]contract.ApprovalStepDisplayMetadata, error) {
	return nil, nil
}
func (*fakeContractApprovals) Clone(context.Context, string, string, string, *models.UserSession) (contract.Record, error) {
	return nil, nil
}
func (*fakeContractApprovals) ListApprovalNotificationFlows(context.Context) ([]contract.FlowDescriptor, error) {
	return nil, nil
}

type fakeContractStandardActions struct{}

func (*fakeContractStandardActions) ResolveStandardAction(context.Context, string) (*contract.StandardActionResolution, error) {
	return nil, nil
}
func (*fakeContractStandardActions) AuthorizeResolvedStandardAction(context.Context, *contract.StandardActionRef, *models.UserSession) *contract.StandardActionOutcome {
	return nil
}
func (*fakeContractStandardActions) ListStandardActions(context.Context, *models.UserSession) ([]contract.StandardActionDescriptor, error) {
	return nil, nil
}
func (*fakeContractStandardActions) InvokeResolvedStandardAction(context.Context, *contract.StandardActionRef, []map[string]any, *models.UserSession) ([]contract.StandardActionInvocationResult, *contract.StandardActionOutcome) {
	return nil, nil
}
func (*fakeContractStandardActions) PreviewResolvedRecordCreate(context.Context, *contract.StandardActionRef, map[string]any, *models.UserSession) (*contract.StandardActionPreviewResult, *contract.StandardActionOutcome) {
	return nil, nil
}
func (*fakeContractStandardActions) PreviewResolvedOutputs(context.Context, *contract.StandardActionRef, string, *models.UserSession) (*contract.StandardActionOutputPreview, *contract.StandardActionOutcome) {
	return nil, nil
}