package workflow

import (
	"github.com/tidbcloud/fastflow/pkg/entity/run"
	"github.com/tidbcloud/pkgv2/db"

	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/awss3"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/clusterproxy"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/dataflow"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/encryptionchange"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/eventbus"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/regionalserver"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/remoteencryptor"
	auditlogrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/auditlog"
	brrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/br"
	repobyocvpcpeering "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/byocvpcpeering"
	clusterrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/cluster"
	bindingrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/clusterencryptionbinding"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/encryptionkey"
	exportrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/export"
	logredactionpolicyrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/logredactionpolicy"
	passwordrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/password"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/privatelink"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/publicconnectionsetting"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/rcuquota"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/region"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/reservedcapacitytemplate"
	resourcepoolrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/resourcepool"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/tidbgroup"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/auditlog"
	brservice "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/br"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/logredactionpolicy"
	resourcepoolsvc "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/resourcepool"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/workflow/action"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/service/workflow/dag"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/pkg/config"
	"github.com/tidbcloud/tidb-management-service/utilities/workflow"
)

// Global action instances - each action is created exactly once
type actionInstances struct {
	createTidbCluster                 run.Action
	createTidbGroup                   run.Action
	pollUntilClusterAvailable         run.Action
	pollUntilTidbGroupAvailable       run.Action
	fullClusterInfo                   run.Action
	execExtraSetUpSql                 run.Action
	createBackupSetting               run.Action
	setGlobalClusterStatus            run.Action
	updatePrivateLb                   run.Action
	createPrivateLinkService          run.Action
	pollPrivateLinkServiceActive      run.Action
	deleteTidbGroup                   run.Action
	deletePrivateLinkService          run.Action
	deleteTidbCluster                 run.Action
	deletePremiumReservedResourcePool run.Action
	updateTidbCluster                 run.Action
	updateSharedPoolPD                run.Action
	updateSharedPoolTiKV              run.Action
	updateSharedPoolTiKVWorker        run.Action
	updateSharedPoolTiDBWorker        run.Action
	updateTiDBGroupTiDB               run.Action
	updateTiDBGroupTiProxy            run.Action
	createLightweightRestore          run.Action
	postLightweightRestoreActions     run.Action
	deleteLightweightRestore          run.Action
	markLightweightRestoreSuccess     run.Action
	grantAccessDedicatedBackupBucket  run.Action
	cleanupDedicatedRestoreAccess     run.Action
	createClassicRestore              run.Action
	deleteClassicRestore              run.Action
	markClassicRestoreSuccess         run.Action
	updatePublicLb                    run.Action
	updateVpcPeeringAllowlist         run.Action
	createPrivateLinkConnection       run.Action
	deletePrivateLinkConnection       run.Action
	updateAuditLogSetting             run.Action
	createAuditLogFilterRule          run.Action
	updateAuditLogFilterRule          run.Action
	deleteAuditLogFilterRule          run.Action
	updateLogRedactionPolicy          run.Action
	pollUntilResourcePoolAvailable    run.Action
	pauseResourcePool                 run.Action
	createPauseManualBackups          run.Action
	finishPausePreparation            run.Action
	pausePreparedResourcePool         run.Action
	resumeResourcePool                run.Action
	initResourcePoolSystemTidb        run.Action
	markCreatedResourcePoolActive     run.Action
	markModifiedResourcePoolActive    run.Action
	pollUntilEncryptionKeyActive      run.Action
	createDefaultEncryptionKey        run.Action
	updateDefaultEncryptionKeyInfo    run.Action
	deleteResourcePool                run.Action
	sendDeleteEventOfResourcePool     run.Action
	createManualBackup                run.Action
	pollManualBackupFinished          run.Action
	createManualBackupRestore         run.Action
	getManualBackupRestorePostActions run.Action
	deleteManualBackupRestore         run.Action
	markManualBackupRestoreSuccess    run.Action
	runCseCtlGenMeta                  run.Action
	runCseCtlSyncMeta                 run.Action
	pollCseCtlStatus                  run.Action
	pollUntilMasterKeyReady           run.Action
	finalizeEncryptionChange          run.Action
	createExport                      run.Action
	createExportTiDBGroup             run.Action
	deleteExportTiDBGroup             run.Action
	pollExport                        run.Action
	cancelExport                      run.Action

	scaleByocSharedComponentsTiKV           run.Action
	scaleByocSharedComponentsTiFlashWrite   run.Action
	scaleByocSharedComponentsTiFlashCompute run.Action
}

func RegisterDags(
	flow workflow.Workflow,
	cfg *config.Config,
	clusterRepo clusterrepo.Repo,
	tidbGroupRepo tidbgroup.Repo,
	publicConnectionSettingRepo publicconnectionsetting.Repo,
	reservedCapacityTemplateRepo reservedcapacitytemplate.Repo,
	byocVpcPeeringRepo repobyocvpcpeering.Repo,
	privateConnRepo privatelink.Repo,
	regionRepo region.Repo,
	resourcePoolRepo resourcepoolrepo.Repo,
	pauseOperationRepo resourcepoolrepo.PauseOperationRepo,
	passwordRepo passwordrepo.Repo,
	auditLogSettingRepo auditlogrepo.SettingRepo,
	auditLogFilterRuleRepo auditlogrepo.FilterRuleRepo,
	logRedactionPolicyRepo logredactionpolicyrepo.Repo,
	restoreRepo brrepo.RestoreRepo,
	backupRepo brrepo.BackupRepo,
	backupSettingRepo brrepo.BackupSettingRepo,
	backupPolicyRepo brrepo.BackupPolicyRepo,
	backupService brservice.Service,
	exportRepo exportrepo.ExportRepo,
	eventCommitter eventbus.WALCommitter,
	regionalCli regionalserver.Client,
	dataflowCli dataflow.DataFlow,
	clusterProxyProvider clusterproxy.Provider,
	transaction db.Transactioner,
	encryptor remoteencryptor.Client,
	auditLogSvc auditlog.Service,
	logRedactionPolicySvc logredactionpolicy.Service,
	resourcePoolSvc resourcepoolsvc.Service,
	encryptionKeyRepo encryptionkey.Repo,
	rcuQuotaRepo rcuquota.Repo,
	bindingRepo bindingrepo.Repo,
	encryptionChangeExecutor encryptionchange.Executor,
	s3Client awss3.GetClient,
) error {
	metadataHelper := action.NewPremiumReservedMetadataHelper(cfg, s3Client, clusterRepo, resourcePoolRepo)
	pauseResourcePoolAction := action.NewPauseResourcePoolAction(
		resourcePoolRepo,
		regionRepo,
		regionalCli,
		backupSettingRepo,
		pauseOperationRepo,
		transaction,
		eventCommitter,
	)
	// Initialize all action instances exactly once
	actions := &actionInstances{
		createTidbCluster: action.NewCreateTidbClusterAction(
			clusterRepo,
			regionRepo,
			regionalCli,
			encryptionKeyRepo,
			rcuQuotaRepo,
			reservedCapacityTemplateRepo,
			resourcePoolRepo,
			metadataHelper,
		),
		createTidbGroup: action.NewCreateTidbGroupAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			regionalCli,
			reservedCapacityTemplateRepo,
			resourcePoolRepo,
		),
		pollUntilClusterAvailable:   action.NewPollUntilClusterAvailableAction(regionalCli, clusterRepo, regionRepo, eventCommitter),
		pollUntilTidbGroupAvailable: action.NewPollUntilTidbGroupAvailableAction(regionalCli, clusterRepo, regionRepo, eventCommitter),
		fullClusterInfo:             action.NewFullClusterInfoAction(regionalCli, clusterRepo, regionRepo),
		execExtraSetUpSql: action.NewExecExtraSetUpSqlAction(
			clusterRepo,
			regionRepo,
			encryptor,
			regionalCli,
			clusterProxyProvider,
			transaction,
		),
		createBackupSetting: action.NewCreateBackupSettingAction(
			backupSettingRepo,
			backupPolicyRepo,
			clusterRepo,
			resourcePoolRepo,
			regionRepo,
			regionalCli,
			transaction,
			cfg,
		),
		setGlobalClusterStatus: action.NewSetGlobalClusterStatusAction(clusterRepo, eventCommitter, transaction),
		updatePrivateLb:        action.NewUpdatePrivateLbAction(clusterRepo, tidbGroupRepo, regionRepo, regionalCli, resourcePoolRepo),
		createPrivateLinkService: action.NewCreatePrivateLinkServiceAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			regionalCli,
			privateConnRepo,
			resourcePoolRepo,
		),
		pollPrivateLinkServiceActive: action.NewPollPrivateLinkServiceActiveAction(
			regionalCli,
			clusterRepo,
			regionRepo,
			privateConnRepo,
			eventCommitter,
		),
		deleteTidbGroup: action.NewDeleteTidbGroupAction(
			clusterRepo,
			regionRepo,
			regionalCli,
			eventCommitter,
			resourcePoolRepo,
		),
		deletePrivateLinkService: action.NewDeletePrivateLinkServiceAction(clusterRepo, regionRepo, regionalCli, resourcePoolRepo),
		deleteTidbCluster: action.NewDeleteTidbClusterAction(
			clusterRepo,
			resourcePoolRepo,
			regionRepo,
			regionalCli,
			eventCommitter,
			metadataHelper,
		),
		deletePremiumReservedResourcePool: action.NewDeletePremiumReservedResourcePoolAction(clusterRepo, resourcePoolSvc),
		updateTidbCluster: action.NewUpdateTidbClusterAction(
			clusterRepo,
			regionRepo,
			regionalCli,
			eventCommitter,
			rcuQuotaRepo,
			resourcePoolRepo,
		),
		updateSharedPoolPD: action.NewUpdateSharedPoolPDAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateSharedPoolTiKV: action.NewUpdateSharedPoolTiKVAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateSharedPoolTiKVWorker: action.NewUpdateSharedPoolTiKVWorkerAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateSharedPoolTiDBWorker: action.NewUpdateSharedPoolTiDBWorkerAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateTiDBGroupTiDB: action.NewUpdateTiDBGroupTiDBAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateTiDBGroupTiProxy: action.NewUpdateTiDBGroupTiProxyAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			reservedCapacityTemplateRepo,
			regionalCli,
			resourcePoolRepo,
		),
		createLightweightRestore: action.NewCreateLightweightRestoreAction(
			restoreRepo,
			regionRepo,
			clusterRepo,
			bindingRepo,
			regionalCli,
			transaction,
			eventCommitter,
			resourcePoolRepo,
		),
		postLightweightRestoreActions: action.NewPostLightweightRestoreActionsAction(
			regionRepo,
			clusterRepo,
			tidbGroupRepo,
			regionalCli,
			clusterProxyProvider,
			encryptor,
		),
		deleteLightweightRestore: action.NewDeleteLightweightRestoreAction(
			restoreRepo,
			regionRepo,
			clusterRepo,
			regionalCli,
			transaction,
		),
		markLightweightRestoreSuccess: action.NewMarkLightweightRestoreSuccessAction(
			restoreRepo,
			regionRepo,
			clusterRepo,
			transaction,
			eventCommitter,
		),
		grantAccessDedicatedBackupBucket: action.NewGrantAccessDedicatedBackupBucketAction(
			restoreRepo,
			clusterRepo,
			regionRepo,
			dataflowCli,
			regionalCli,
		),
		cleanupDedicatedRestoreAccess: action.NewCleanupDedicatedRestoreAccessAction(restoreRepo, dataflowCli),
		createClassicRestore: action.NewCreateClassicRestoreAction(
			restoreRepo,
			clusterRepo,
			regionRepo,
			dataflowCli,
			regionalCli,
			cfg,
			transaction,
			eventCommitter,
			resourcePoolRepo,
		),
		deleteClassicRestore: action.NewDeleteClassicRestoreAction(
			restoreRepo,
			regionRepo,
			clusterRepo,
			regionalCli,
		),
		markClassicRestoreSuccess: action.NewMarkClassicRestoreSuccessAction(
			restoreRepo,
			transaction,
			eventCommitter,
		),
		updatePublicLb: action.NewUpdatePublicLbAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			publicConnectionSettingRepo,
			regionalCli,
			eventCommitter,
		),
		updateVpcPeeringAllowlist: action.NewUpdateVpcPeeringAllowlistAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			byocVpcPeeringRepo,
			regionalCli,
			resourcePoolRepo,
		),
		createPrivateLinkConnection: action.NewCreatePrivateLinkConnectionAction(
			clusterRepo,
			privateConnRepo,
			regionRepo,
			regionalCli,
			resourcePoolRepo,
			eventCommitter,
		),
		deletePrivateLinkConnection: action.NewDeletePrivateLinkConnectionAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			regionalCli,
			resourcePoolRepo,
		),
		updateAuditLogSetting: action.NewUpdateAuditLogSettingAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			auditLogSettingRepo,
			regionalCli,
			auditLogSvc,
			cfg,
			resourcePoolRepo,
		),
		createAuditLogFilterRule: action.NewCreateAuditLogFilterRuleAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			auditLogFilterRuleRepo,
			auditLogSvc,
			cfg,
			resourcePoolRepo,
		),
		updateAuditLogFilterRule: action.NewUpdateAuditLogFilterRuleAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			auditLogFilterRuleRepo,
			auditLogSvc,
			cfg,
			resourcePoolRepo,
		),
		deleteAuditLogFilterRule: action.NewDeleteAuditLogFilterRuleAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			auditLogSvc,
			cfg,
			resourcePoolRepo,
		),
		updateLogRedactionPolicy: action.NewUpdateLogRedactionPolicyAction(
			clusterRepo,
			tidbGroupRepo,
			regionRepo,
			logRedactionPolicyRepo,
			regionalCli,
			logRedactionPolicySvc,
			cfg,
			resourcePoolRepo,
		),
		pollUntilResourcePoolAvailable: action.NewPollUntilResourcePoolAvailableAction(
			regionalCli,
			resourcePoolRepo,
			regionRepo,
			eventCommitter),
		pauseResourcePool: pauseResourcePoolAction,
		createPauseManualBackups: action.NewCreatePauseManualBackupsAction(
			resourcePoolRepo,
			pauseOperationRepo,
			clusterRepo,
			restoreRepo,
			backupService,
			transaction,
		),
		finishPausePreparation: action.NewFinishPausePreparationAction(
			resourcePoolRepo,
			pauseOperationRepo,
			clusterRepo,
			backupRepo,
			resourcePoolSvc,
			transaction,
			eventCommitter,
		),
		pausePreparedResourcePool: action.NewPausePreparedResourcePoolAction(
			pauseOperationRepo,
			pauseResourcePoolAction,
		),
		resumeResourcePool: action.NewResumeResourcePoolAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
			backupSettingRepo,
			pauseOperationRepo,
			transaction,
			eventCommitter,
		),
		initResourcePoolSystemTidb: action.NewInitResourcePoolSystemTidbAction(
			resourcePoolRepo,
			regionRepo,
			passwordRepo,
			regionalCli,
			encryptor,
			clusterProxyProvider,
		),
		markCreatedResourcePoolActive: action.NewMarkCreatedResourcePoolActiveAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		markModifiedResourcePoolActive: action.NewMarkModifiedResourcePoolActiveAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		pollUntilEncryptionKeyActive: action.NewPollUntilEncryptionKeyActiveAction(
			regionalCli,
			clusterRepo,
			resourcePoolRepo,
			regionRepo,
			encryptionKeyRepo,
		),
		createDefaultEncryptionKey: action.NewCreateDefaultEncryptionKeyAction(
			regionalCli,
			regionRepo,
			encryptionKeyRepo,
		),
		updateDefaultEncryptionKeyInfo: action.NewUpdateDefaultEncryptionKeyInfoAction(
			regionalCli,
			regionRepo,
			encryptionKeyRepo,
		),
		deleteResourcePool: action.NewDeleteResourcePoolAction(
			regionalCli,
			resourcePoolRepo,
			regionRepo,
			eventCommitter,
			metadataHelper,
		),
		sendDeleteEventOfResourcePool: action.NewSendDeleteEventOfResourcePoolAction(
			regionalCli,
			resourcePoolRepo,
			regionRepo,
			eventCommitter,
		),
		createExport: action.NewCreateExportAction(
			exportRepo,
			clusterRepo,
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		createExportTiDBGroup: action.NewCreateExportTiDBGroupAction(
			exportRepo,
			clusterRepo,
			resourcePoolRepo,
			regionRepo,
			regionalCli,
			transaction,
		),
		deleteExportTiDBGroup: action.NewDeleteExportTiDBGroupAction(exportRepo, regionRepo, regionalCli),
		pollExport:            action.NewPollExportAction(exportRepo, regionRepo, regionalCli, transaction, eventCommitter),
		cancelExport:          action.NewCancelExportAction(exportRepo, regionRepo, regionalCli),
		scaleByocSharedComponentsTiKV: action.NewScaleByocSharedComponentsTiKVAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		scaleByocSharedComponentsTiFlashWrite: action.NewScaleByocSharedComponentsTiFlashWriteAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		scaleByocSharedComponentsTiFlashCompute: action.NewScaleByocSharedComponentsTiFlashComputeAction(
			resourcePoolRepo,
			regionRepo,
			regionalCli,
		),
		createManualBackup: action.NewCreateManualBackup(
			backupRepo,
			regionRepo,
			clusterRepo,
			resourcePoolRepo,
			pauseOperationRepo,
			regionalCli,
			transaction,
			eventCommitter,
		),
		runCseCtlGenMeta: action.NewRunCseCtlGenMetaAction(
			clusterRepo,
			regionRepo,
			encryptionChangeExecutor,
			encryptionKeyRepo,
		),
		runCseCtlSyncMeta: action.NewRunCseCtlSyncMetaAction(
			clusterRepo,
			regionRepo,
			encryptionChangeExecutor,
		),
		pollCseCtlStatus: action.NewPollCseCtlStatusAction(
			clusterRepo,
			regionRepo,
			encryptionChangeExecutor,
		),
		pollUntilMasterKeyReady: action.NewPollUntilMasterKeyReadyAction(
			encryptionKeyRepo,
		),
		finalizeEncryptionChange: action.NewFinalizeEncryptionChangeAction(
			clusterRepo,
			bindingRepo,
			encryptionKeyRepo,
			transaction,
		),
		pollManualBackupFinished: action.NewPollManualBackupFinished(
			backupRepo,
			regionRepo,
			clusterRepo,
			regionalCli,
			transaction,
			eventCommitter,
		),
		createManualBackupRestore: action.NewCreateManualBackupRestore(
			restoreRepo,
			regionRepo,
			clusterRepo,
			bindingRepo,
			regionalCli,
			transaction,
			eventCommitter,
			resourcePoolRepo,
		),
		getManualBackupRestorePostActions: action.NewGetManualBackupRestorePostActions(
			regionRepo,
			clusterRepo,
			tidbGroupRepo,
			regionalCli,
			clusterProxyProvider,
			encryptor,
		),
		deleteManualBackupRestore: action.NewDeleteManualBackupRestore(
			regionRepo,
			clusterRepo,
			regionalCli,
		),
		markManualBackupRestoreSuccess: action.NewMarkManualBackupRestoreSuccess(
			restoreRepo,
			regionRepo,
			clusterRepo,
			transaction,
			eventCommitter,
		),
	}

	// Build action slices for each DAG by referencing the shared instances
	createClusterActions := []run.Action{
		actions.pollUntilEncryptionKeyActive,
		actions.createTidbCluster,
		actions.createTidbGroup,
		actions.pollUntilClusterAvailable,
		actions.pollUntilTidbGroupAvailable,
		actions.fullClusterInfo,
		actions.execExtraSetUpSql,
		actions.createBackupSetting,
		actions.setGlobalClusterStatus,
	}

	createPrivateLinkServiceActions := []run.Action{
		actions.updatePrivateLb,
		actions.createPrivateLinkService,
		actions.pollPrivateLinkServiceActive,
	}

	deleteClusterActions := []run.Action{
		actions.deleteTidbGroup,
		actions.deletePrivateLinkService,
		actions.deleteTidbCluster,
		actions.deletePremiumReservedResourcePool,
	}

	updateClusterActions := []run.Action{
		actions.updateTidbCluster,
		actions.pollUntilClusterAvailable,
		actions.pollUntilTidbGroupAvailable,
		actions.setGlobalClusterStatus,
	}

	updateClusterTopologyActions := []run.Action{
		actions.updateSharedPoolPD,
		actions.updateSharedPoolTiKV,
		actions.updateSharedPoolTiKVWorker,
		actions.updateSharedPoolTiDBWorker,
		actions.updateTiDBGroupTiDB,
		actions.updateTiDBGroupTiProxy,
		actions.setGlobalClusterStatus,
	}

	restoreClusterActions := []run.Action{
		actions.createLightweightRestore,
		actions.postLightweightRestoreActions,
		actions.deleteLightweightRestore,
		actions.markLightweightRestoreSuccess,
	}

	restoreClusterFromDedicatedActions := []run.Action{
		actions.grantAccessDedicatedBackupBucket,
		actions.cleanupDedicatedRestoreAccess,
		actions.createClassicRestore,
		actions.deleteClassicRestore,
		actions.markClassicRestoreSuccess,
	}

	restoreClusterFromClassicActions := []run.Action{
		actions.createClassicRestore,
		actions.deleteClassicRestore,
		actions.markClassicRestoreSuccess,
	}

	updatePublicLbActions := []run.Action{
		actions.updatePublicLb,
	}

	updateVpcPeeringAllowlistActions := []run.Action{
		actions.updateVpcPeeringAllowlist,
	}

	createPrivateLinkConnectionActions := []run.Action{
		actions.createPrivateLinkConnection,
	}

	deletePrivateLinkConnectionActions := []run.Action{
		actions.deletePrivateLinkConnection,
	}

	deletePrivateLinkServiceActions := []run.Action{
		actions.deletePrivateLinkService,
	}

	updateAuditLogSettingActions := []run.Action{
		actions.updateAuditLogSetting,
	}

	createAuditLogFilterRuleActions := []run.Action{
		actions.createAuditLogFilterRule,
	}

	updateAuditLogFilterRuleActions := []run.Action{
		actions.updateAuditLogFilterRule,
	}

	deleteAuditLogFilterRuleActions := []run.Action{
		actions.deleteAuditLogFilterRule,
	}

	updateLogRedactionPolicyActions := []run.Action{
		actions.updateLogRedactionPolicy,
	}

	postCreateResourcePoolActions := []run.Action{
		actions.pollUntilResourcePoolAvailable,
		actions.initResourcePoolSystemTidb,
		actions.markCreatedResourcePoolActive,
	}

	pauseResourcePoolActions := []run.Action{actions.pauseResourcePool}
	prepareAndPauseResourcePoolActions := []run.Action{
		actions.createPauseManualBackups,
		actions.finishPausePreparation,
		actions.pausePreparedResourcePool,
	}
	resumeResourcePoolActions := []run.Action{actions.resumeResourcePool}

	createDefaultEncryptionKeyActions := []run.Action{
		actions.createDefaultEncryptionKey,
		actions.updateDefaultEncryptionKeyInfo,
	}

	deleteTidbGroupActions := []run.Action{
		actions.deleteTidbGroup,
	}

	createTidbGroupActions := []run.Action{
		actions.createTidbGroup,
		actions.pollUntilTidbGroupAvailable,
	}

	deleteResourcePoolActions := []run.Action{
		actions.deleteResourcePool,
		actions.sendDeleteEventOfResourcePool,
	}

	createExportActions := []run.Action{
		actions.createExportTiDBGroup,
		actions.pollUntilTidbGroupAvailable,
		actions.createExport,
		actions.pollExport,
		actions.deleteExportTiDBGroup,
	}

	cancelExportActions := []run.Action{
		actions.cancelExport,
		actions.deleteExportTiDBGroup,
	}
	scaleByocSharedComponentsActions := []run.Action{
		actions.scaleByocSharedComponentsTiKV,
		actions.scaleByocSharedComponentsTiFlashWrite,
		actions.scaleByocSharedComponentsTiFlashCompute,
		actions.markModifiedResourcePoolActive,
	}

	createManualBackupActions := []run.Action{
		actions.createManualBackup,
		actions.pollManualBackupFinished,
	}

	restoreFromManualBackupActions := []run.Action{
		actions.createManualBackupRestore,
		actions.getManualBackupRestorePostActions,
		actions.deleteManualBackupRestore,
		actions.markManualBackupRestoreSuccess,
	}

	updateClusterEncryptionActions := []run.Action{
		actions.pollUntilMasterKeyReady,
		actions.runCseCtlGenMeta,
		actions.runCseCtlSyncMeta,
		actions.pollCseCtlStatus,
		actions.finalizeEncryptionChange,
	}

	// Register DAGs with shared action instances
	if err := flow.RegisterDag(dag.CreateClusterDag(), createClusterActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreatePrivateLinkServiceDag(), createPrivateLinkServiceActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeleteClusterDag(), deleteClusterActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateClusterDag(), updateClusterActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateClusterTopologyDag(), updateClusterTopologyActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.RestoreClusterDag(), restoreClusterActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.RestoreClusterFromDedicatedDag(), restoreClusterFromDedicatedActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.RestoreClusterFromClassicDag(), restoreClusterFromClassicActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdatePublicLbDag(), updatePublicLbActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateVpcPeeringAllowlistDag(), updateVpcPeeringAllowlistActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreatePrivateLinkConnectionDag(), createPrivateLinkConnectionActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeletePrivateLinkConnectionDag(), deletePrivateLinkConnectionActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeletePrivateLinkServiceDag(), deletePrivateLinkServiceActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateAuditLogSettingDag(), updateAuditLogSettingActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreateAuditLogFilterRuleDag(), createAuditLogFilterRuleActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateAuditLogFilterRuleDag(), updateAuditLogFilterRuleActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeleteAuditLogFilterRuleDag(), deleteAuditLogFilterRuleActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.UpdateLogRedactionPolicyDag(), updateLogRedactionPolicyActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.PostCreateResourcePoolDag(), postCreateResourcePoolActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.PauseResourcePoolDag(), pauseResourcePoolActions); err != nil {
		return err
	}
	if err := flow.RegisterDag(dag.PrepareAndPauseResourcePoolDag(), prepareAndPauseResourcePoolActions); err != nil {
		return err
	}
	if err := flow.RegisterDag(dag.ResumeResourcePoolDag(), resumeResourcePoolActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreateDefaultEncryptionKeyDag(), createDefaultEncryptionKeyActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeleteTidbGroupDag(), deleteTidbGroupActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreateTidbGroupDag(), createTidbGroupActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.DeleteResourcePoolDag(), deleteResourcePoolActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreateExportDag(), createExportActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CancelExportDag(), cancelExportActions); err != nil {
		return err
	}
	if err := flow.RegisterDag(dag.ScaleByocSharedComponentsDag(), scaleByocSharedComponentsActions); err != nil {
		return err
	}
	if err := flow.RegisterDag(dag.UpdateClusterEncryptionDag(), updateClusterEncryptionActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.CreateManualBackupDag(), createManualBackupActions); err != nil {
		return err
	}

	if err := flow.RegisterDag(dag.RestoreFromManualBackupDag(), restoreFromManualBackupActions); err != nil {
		return err
	}

	return nil
}