import {
  Alert,
  Button,
  Divider,
  Group,
  Loader,
  notifier,
  Paper,
  SelectProps,
  Stack,
  Typography
} from '@tidbcloud/uikit'
import { FormErrorMessage, FormSelect } from '@tidbcloud/uikit/biz'
import { IconAlertCircle, IconCheck } from '@tidbcloud/uikit/icons'
import { useEffect, useId, useMemo } from 'react'
import { FormProvider, useForm, useFormContext } from 'react-hook-form'
import { useHistory, useLocation } from 'react-router-dom'

import { HeroComponent, isHeroQueryReady } from 'dbaas/components/Measurement'
import TimeComponent from 'dbaas/components/TimeComponent'
import { PageAccessGuard } from 'dbaas/contexts/access-control'
import { useOrgProjectClusterIds } from 'dbaas/features/Common'
import {
  CloudProviderConst,
  CloudProviderLabelConst,
  filterUserProfileProjects,
  getCloudProviderLabel
} from 'dbaas/features/Project'
import { queryClient } from 'dbaas/reactQueryClient'
import { filterEssentialRegionsByServicePlan } from 'dbaas/screens/NextGen/my-tidb-creation/plans/essential/essential-regions'
import { ESSENTIAL_V2_RCU_MIN } from 'dbaas/screens/NextGen/my-tidb-creation/plans/EssentialV2/schema'
import { HighAvailabilitySection as EssentialV2HighAvailabilitySection } from 'dbaas/screens/NextGen/my-tidb-creation/plans/EssentialV2/sections/HighAvailabilitySection'
import { EssentialV2Cost } from 'dbaas/screens/NextGen/my-tidb-creation/plans/EssentialV2/summary/EssentialV2Cost'
import { BasicSettingsSection as PremiumBasicSettingsSection } from 'dbaas/screens/NextGen/my-tidb-creation/plans/premium/sections/BasicSettingsSection'
import { CapacitySection as PremiumCapacitySection } from 'dbaas/screens/NextGen/my-tidb-creation/plans/premium/sections/CapacitySection'
import { HighAvailabilitySection as PremiumHighAvailabilitySection } from 'dbaas/screens/NextGen/my-tidb-creation/plans/premium/sections/HighAvailabilitySection'
import { CapacitySection as PremiumReservedCapacitySection } from 'dbaas/screens/NextGen/my-tidb-creation/plans/premium-reserved/sections/CapacitySection'
import { PremiumReservedPricingCost } from 'dbaas/screens/NextGen/my-tidb-creation/plans/premium-reserved/summary/PremiumReservedPricingCost'
import { FormItem } from 'dbaas/screens/NextGen/my-tidb-creation/shared/FormItem'
import { BasicSettingsSection as SharedBasicSettingsSection } from 'dbaas/screens/NextGen/my-tidb-creation/shared/premium-byoc/basic-settings/BasicSettingsSection'
import {
  invalidateCapacityLimitsQueries,
  PREMIUM_MAX_RCU_FALLBACK,
  PREMIUM_MIN_RCU,
  useCapacityLimits
} from 'dbaas/screens/NextGen/my-tidb-creation/shared/premium-byoc/capacity/use-capacity-limits'
import { PremiumByocFormValue } from 'dbaas/screens/NextGen/my-tidb-creation/shared/premium-byoc/types'
import { usePremiumReservedFeatEnabled } from 'dbaas/screens/NextGen/my-tidb-creation/shared/premium-reserved/use-premium-reserved-feat-enabled'
import { useVirtualProjectId } from 'dbaas/screens/NextGen/my-tidb-creation/shared/use-virtual-project-id'
import { useCreateResourceRoleState } from 'dbaas/screens/NextGen/shared/access/create-resource-role'
import { RestoreLayout } from 'dbaas/screens/Restore/RestoreLayout'
import { RestoreSummaryCard, RestoreSummaryItem, RestoreSummarySection } from 'dbaas/screens/Restore/RestoreSummary'
import { useListClusters, useListDeletedClusters } from 'dbaas/services'
import { useGetUserProfileV2 } from 'dbaas/services/account'
import {
  useRegionServiceListRegions,
  useTidbServiceRestoreTidb
} from 'dbaas/services/api-clients/v2025/tidb-management/v1beta2'
import {
  Commonv1beta1Region,
  Commonv1beta1ServicePlan,
  V1beta1RegionCloudProvider,
  V1beta2TidbHighAvailabilityType
} from 'dbaas/services/api-clients/v2025/tidb-management/v1beta2/interface'
import { useListBackups } from 'dbaas/services/dataflow'
import { DataflowBackup } from 'dbaas/services/dataflow/interface'
import { getErrorMessage } from 'dbaas/services/errorCodes'
import useStores from 'dbaas/stores/useStores'
import { MixpanelEvents } from 'dbaas/utils/tracking'

import { getDisplayServicePlan } from '../../shared/tidb-instance/service-plan/ServicePlanTag'

import { EssentialV2RestoreCapacitySection } from './EssentialV2RestoreCapacitySection'
import {
  getRestoreFromDedicatedTargetPlan,
  isCmekSourceUnsupported,
  removeCloudProviderFromRegionId
} from './restoreFromDedicatedUtils'

type RestoreFromDedicatedFormData = Pick<
  PremiumByocFormValue,
  | 'projectId'
  | 'name'
  | 'cloudProvider'
  | 'regionId'
  | 'minRcu'
  | 'maxRcu'
  | 'highAvailabilityType'
  | 'reservedCapacityTemplateId'
> & {
  sourceProjectId: string
  sourceProjectUsesCmek: boolean
  clusterStatus: 'active' | 'deleted'
  plan: string
  fromClusterId: string
  fromClusterName?: string
  backupId: string
  backup?: DataflowBackup
}

const renderClusterOption: SelectProps['renderOption'] = ({ option, checked }) => {
  // @ts-ignore
  const time = option.createdAt || option.deletedAt
  const label = 'createdAt' in option ? 'Created at' : 'Deleted at'

  return (
    <Group wrap="nowrap" justify="space-between" sx={{ flex: 1 }}>
      <Group gap={8}>
        <Typography variant="title-md" fw={checked ? 500 : 400}>
          {option.label}
        </Typography>
        <Typography variant="body-lg" c="carbon.7">
          {label}: <TimeComponent time={time} />
        </Typography>
      </Group>

      {checked && <IconCheck size={16} strokeWidth={3} style={{ marginInlineStart: 'auto' }} />}
    </Group>
  )
}

const clearSelectedCluster = (methods: ReturnType<typeof useFormContext<RestoreFromDedicatedFormData>>) => {
  methods.setValue('fromClusterId', '')
  methods.setValue('fromClusterName', '')
}

const clearSelectedBackup = (methods: ReturnType<typeof useFormContext<RestoreFromDedicatedFormData>>) => {
  methods.setValue('backupId', '')
  methods.setValue('backup', undefined)
}

const SelectBackupSection = ({ servicePlan }: { servicePlan: Commonv1beta1ServicePlan }) => {
  const methods = useFormContext<RestoreFromDedicatedFormData>()
  const { orgId } = useOrgProjectClusterIds()
  const { data, isFetched, isError } = useGetUserProfileV2({
    query: {
      refetchOnWindowFocus: false,
      refetchOnMount: false,
      select: (profile) => ({
        ...profile,
        projects: filterUserProfileProjects(profile.projects)
      })
    }
  })

  const projectOptions = data?.projects
    .filter((item) => item.org_id === orgId)
    .map((project) => ({
      label: project.name,
      value: project.id,
      disabled: servicePlan !== 'Essential_V2' && project.aws_cmek_enabled
    }))

  const sourceProjectId = methods.watch('sourceProjectId')
  const sourceProjectUsesCmek =
    data?.projects.some(
      (project) => project.org_id === orgId && project.id === sourceProjectId && project.aws_cmek_enabled
    ) ?? false
  const status = methods.watch('clusterStatus')
  const provider = methods.watch('cloudProvider')
  const fromClusterId = methods.watch('fromClusterId')

  useEffect(() => {
    methods.setValue('sourceProjectUsesCmek', sourceProjectUsesCmek)
  }, [methods, sourceProjectUsesCmek])

  const {
    data: activeClusterData,
    isLoading: isLoadingActiveClusters,
    error: listClusterError
  } = useListClusters(
    orgId,
    sourceProjectId,
    {
      provider,
      per_page: 1000
    },
    {
      query: {
        enabled: !!sourceProjectId && status === 'active',
        refetchOnWindowFocus: false,
        refetchOnMount: false
      }
    }
  )

  const {
    data: deletedClusterData,
    isLoading: isLoadingDeletedClusters,
    error: listDeletedClustersError
  } = useListDeletedClusters(
    orgId,
    sourceProjectId,
    {
      per_page: 1000,
      provider
    },
    {
      query: {
        enabled: !!sourceProjectId && status === 'deleted',
        refetchOnWindowFocus: false,
        refetchOnMount: false
      }
    }
  )

  const clusterOptions = useMemo(() => {
    if (status === 'active') {
      return (
        activeClusterData?.items.map((item) => ({
          label: item.name,
          value: item.id,
          createdAt: item.created_at
        })) ?? []
      )
    }

    if (status === 'deleted') {
      return (
        deletedClusterData?.items.map((item) => ({
          label: item.name,
          value: item.id,
          deletedAt: item.delete_time
        })) ?? []
      )
    }

    return []
  }, [activeClusterData?.items, deletedClusterData?.items, status])

  const {
    data: backupData,
    isLoading: isLoadingBackups,
    error: listBackupsError
  } = useListBackups(
    orgId,
    sourceProjectId,
    fromClusterId,
    {
      per_page: 1000,
      page: 1,
      status: 'BACKUP_STATUS_SUCCESS'
    },
    {
      query: {
        enabled: !!orgId && !!sourceProjectId && !!fromClusterId,
        refetchOnWindowFocus: false,
        refetchOnMount: false
      }
    }
  )

  const backupOptions = useMemo(() => {
    return (
      backupData?.items.map((item) => ({
        label: `${item.name} (${item.regions?.map((region) => region.name).join(', ')})`,
        value: item.id,
        data: item
      })) ?? []
    )
  }, [backupData?.items])

  return (
    <FormItem label="Select Backup" description="Confirm the backup data you want to restore.">
      <HeroComponent ready={isHeroQueryReady({ isFetched, isError })} />
      <Stack gap="md">
        <FormSelect
          name="sourceProjectId"
          label="Project"
          placeholder="Select a project"
          searchable
          data={projectOptions}
          rules={{ required: 'Required' }}
          onChange={() => {
            clearSelectedCluster(methods)
            clearSelectedBackup(methods)
          }}
        />

        <Group align="flex-start">
          <FormSelect
            name="clusterStatus"
            label="Cluster Status"
            data={[
              { label: 'Active', value: 'active' },
              { label: 'Deleted', value: 'deleted' }
            ]}
            onChange={() => {
              clearSelectedCluster(methods)
              clearSelectedBackup(methods)
            }}
          />

          <FormSelect label="Plan" name="plan" data={[{ label: 'Dedicated', value: 'dedicated' }]} disabled />

          <FormSelect
            label="Cloud Provider"
            name="cloudProvider"
            data={[{ label: CloudProviderLabelConst.aws, value: CloudProviderConst.AWS }]}
            disabled
          />
        </Group>

        <FormSelect
          label="Cluster"
          name="fromClusterId"
          searchable
          placeholder={
            clusterOptions.length
              ? 'Select a cluster'
              : 'No clusters available, please select another project or status'
          }
          data={clusterOptions}
          rules={{ required: 'Required' }}
          disabled={isLoadingActiveClusters || isLoadingDeletedClusters}
          rightSection={isLoadingActiveClusters || isLoadingDeletedClusters ? <Loader size="xs" /> : null}
          renderOption={renderClusterOption}
          error={
            listClusterError
              ? `Error loading clusters: ${getErrorMessage(listClusterError, true)}`
              : listDeletedClustersError
                ? `Error loading deleted clusters: ${getErrorMessage(listDeletedClustersError, true)}`
                : undefined
          }
          onChange={(_, option) => {
            methods.setValue('fromClusterName', option?.label ?? '')
            clearSelectedBackup(methods)
          }}
        />

        <FormSelect
          label="Backup Snapshot"
          name="backupId"
          searchable
          placeholder={
            backupOptions.length
              ? 'Select a backup snapshot'
              : 'No backup snapshots available, please select another cluster'
          }
          data={backupOptions}
          rules={{ required: 'Required' }}
          disabled={isLoadingBackups}
          rightSection={isLoadingBackups ? <Loader size="xs" /> : null}
          error={listBackupsError ? `Error loading backups: ${getErrorMessage(listBackupsError, true)}` : undefined}
          onChange={(value) => {
            methods.setValue('backup', backupOptions.find((item) => item.value === value)?.data)
          }}
        />

        {servicePlan === Commonv1beta1ServicePlan.Essential_V2 && sourceProjectUsesCmek && (
          <Alert color="yellow" icon={<IconAlertCircle />} data-testid="restore-from-dedicated-cmek-warning">
            Restoring from a CMEK-enabled Dedicated cluster to Essential is not supported. Select a cluster from a
            project without CMEK to continue.
          </Alert>
        )}
      </Stack>
    </FormItem>
  )
}

const DestinationConfigSection = ({
  regions,
  projectOptions,
  effectiveProjectId,
  projectOptional,
  onProjectCreated,
  servicePlan
}: {
  regions: Commonv1beta1Region[]
  projectOptions: { value: string; label: string }[]
  effectiveProjectId: string
  projectOptional: boolean
  onProjectCreated: () => void
  servicePlan: Commonv1beta1ServicePlan
}) => {
  const methods = useFormContext<RestoreFromDedicatedFormData>()

  return (
    <>
      <Stack gap={4} p="xl" pb={0}>
        <Typography variant="title-lg" fz={20}>
          Restore to a New {getDisplayServicePlan(servicePlan)} Instance
        </Typography>
        <Typography variant="body-lg" c="carbon.7">
          Set up your new instance for restoration. The cloud provider and region of the new instance are the same as
          the backup.
        </Typography>
      </Stack>

      {servicePlan === Commonv1beta1ServicePlan.Essential_V2 ? (
        <SharedBasicSettingsSection
          servicePlan={servicePlan}
          cloudProviders={[methods.watch('cloudProvider') as V1beta1RegionCloudProvider]}
          regions={regions}
          disabled
          projectOptions={projectOptions}
          onProjectCreated={onProjectCreated}
          withFormLabel={false}
          projectOptional={projectOptional}
        />
      ) : (
        <PremiumBasicSettingsSection
          cloudProviders={[methods.watch('cloudProvider') as V1beta1RegionCloudProvider]}
          regions={regions}
          disabled
          projectOptions={projectOptions}
          onProjectCreated={onProjectCreated}
          withFormLabel={false}
          projectOptional={projectOptional}
        />
      )}
      <Divider />
      {servicePlan === Commonv1beta1ServicePlan.Essential_V2 ? (
        <EssentialV2RestoreCapacitySection projectId={effectiveProjectId} />
      ) : servicePlan === Commonv1beta1ServicePlan.Premium_Reserved ? (
        <PremiumReservedCapacitySection projectId={effectiveProjectId} />
      ) : (
        <PremiumCapacitySection projectId={effectiveProjectId} />
      )}
      <Divider />
      {servicePlan === Commonv1beta1ServicePlan.Essential_V2 ? (
        <EssentialV2HighAvailabilitySection />
      ) : (
        <PremiumHighAvailabilitySection />
      )}
    </>
  )
}

const RestoreFromDedicatedSummary = ({
  formId,
  onCancel,
  regions,
  restore,
  submitDisabled,
  servicePlan,
  projectId
}: {
  formId: string
  onCancel: () => void
  regions: Commonv1beta1Region[]
  restore: ReturnType<typeof useTidbServiceRestoreTidb>
  submitDisabled: boolean
  servicePlan: Commonv1beta1ServicePlan
  projectId: string
}) => {
  const methods = useFormContext<RestoreFromDedicatedFormData>()
  const { formState } = methods
  const backup = methods.watch('backup')
  const fromClusterName = methods.watch('fromClusterName')
  const name = methods.watch('name')
  const cloudProvider = methods.watch('cloudProvider')
  const regionId = methods.watch('regionId')
  const maxRcu = methods.watch('maxRcu')
  const highAvailabilityType = methods.watch('highAvailabilityType')
  const clusterStatus = methods.watch('clusterStatus')

  const regionName = regions.find((item) => item.regionId === regionId)?.displayName ?? regionId ?? '-'

  return (
    <RestoreSummaryCard
      description="Your new instance will be:"
      footer={
        <>
          {servicePlan === Commonv1beta1ServicePlan.Essential_V2 ? (
            <EssentialV2Cost
              cloudProvider={cloudProvider as V1beta1RegionCloudProvider}
              regionId={regionId}
              minRcu={methods.watch('minRcu') ?? ESSENTIAL_V2_RCU_MIN}
              maxRcu={maxRcu ?? ESSENTIAL_V2_RCU_MIN}
            />
          ) : servicePlan === Commonv1beta1ServicePlan.Premium_Reserved ? (
            <PremiumReservedPricingCost cloudProvider={cloudProvider} region={regionId} projectId={projectId} />
          ) : null}
          <Stack gap="md">
            <FormErrorMessage message={getErrorMessage(restore.error, true)} />
            <Group gap="md">
              <Button
                variant="default"
                onClick={onCancel}
                data-mp-event={
                  servicePlan === Commonv1beta1ServicePlan.Essential_V2
                    ? MixpanelEvents.EssentialRestore.Create.CancelClicked
                    : 'restore_from_dedicated_cancel'
                }
              >
                Cancel
              </Button>
              <Button
                type="submit"
                form={formId}
                loading={restore.isLoading}
                disabled={submitDisabled}
                sx={{ flexGrow: 1 }}
                data-mp-event={
                  servicePlan === Commonv1beta1ServicePlan.Essential_V2
                    ? MixpanelEvents.EssentialRestore.Create.SubmitClicked
                    : 'restore_from_dedicated_restore'
                }
              >
                Restore
              </Button>
            </Group>
          </Stack>
        </>
      }
    >
      <RestoreSummarySection title="Select Backup">
        <RestoreSummaryItem label="Dedicated Cluster" value={fromClusterName || backup?.cluster?.cluster_id || '-'} />
        <RestoreSummaryItem label="Cluster Status" value={clusterStatus === 'deleted' ? 'Deleted' : 'Active'} />
        <RestoreSummaryItem label="Snapshot" value={backup?.name || '-'} />
      </RestoreSummarySection>

      <RestoreSummarySection title={`Restore to a New ${getDisplayServicePlan(servicePlan)} Instance`}>
        <RestoreSummaryItem label="Name" value={name || '-'} isError={!!formState.errors.name} />
        <RestoreSummaryItem label="Provider" value={cloudProvider ? getCloudProviderLabel(cloudProvider) : '-'} />
        <RestoreSummaryItem label="Region" value={regionName || '-'} />
        <RestoreSummaryItem
          label="Capacity"
          value={maxRcu ? `Maximum RCU = ${Number(maxRcu).toLocaleString()}` : '-'}
        />
        <RestoreSummaryItem
          label="High Availability"
          value={highAvailabilityType === V1beta2TidbHighAvailabilityType.REGIONAL ? 'Regional' : 'Zonal'}
        />
      </RestoreSummarySection>
    </RestoreSummaryCard>
  )
}

const RestoreFromDedicated = () => {
  const history = useHistory()
  const formId = useId()
  const { orgId, projectId: currentProjectId } = useOrgProjectClusterIds()
  const virtualProjectId = useVirtualProjectId()
  const { isAnyProjectOwner, isOrgOwner, ownerProjects } = useCreateResourceRoleState()
  const location = useLocation()
  const requestedServicePlan = getRestoreFromDedicatedTargetPlan(location.search)
  const {
    premiumReservedMode,
    isError: isPremiumReservedFeatError,
    isLoading: isLoadingPremiumReservedFeature
  } = usePremiumReservedFeatEnabled()
  const isPremiumReservedEnabled = (isPremiumReservedFeatError ? 'hidden' : premiumReservedMode) !== 'hidden'
  const servicePlan =
    requestedServicePlan === Commonv1beta1ServicePlan.Premium_Reserved
      ? isPremiumReservedEnabled
        ? Commonv1beta1ServicePlan.Premium_Reserved
        : Commonv1beta1ServicePlan.Premium
      : requestedServicePlan
  const {
    actions: { fetchUserProfileV2 }
  } = useStores()
  const methods = useForm<RestoreFromDedicatedFormData>({
    mode: 'onChange',
    defaultValues: {
      clusterStatus: 'active',
      plan: 'dedicated',
      projectId: '',
      sourceProjectId: '',
      sourceProjectUsesCmek: false,
      fromClusterId: '',
      fromClusterName: '',
      backupId: '',
      name: '',
      cloudProvider: CloudProviderConst.AWS,
      regionId: '',
      maxRcu:
        requestedServicePlan === Commonv1beta1ServicePlan.Premium_Reserved
          ? 0
          : requestedServicePlan === Commonv1beta1ServicePlan.Essential_V2
            ? 10000
            : 20000,
      reservedCapacityTemplateId: '',
      highAvailabilityType:
        requestedServicePlan === Commonv1beta1ServicePlan.Essential_V2
          ? V1beta2TidbHighAvailabilityType.ZONAL
          : V1beta2TidbHighAvailabilityType.REGIONAL
    }
  })

  const backup = methods.watch('backup')
  const selectedProjectId = methods.watch('projectId')
  const effectiveProjectId = isOrgOwner ? selectedProjectId || virtualProjectId : selectedProjectId
  const cloudProvider = methods.watch('cloudProvider')
  const regionId = methods.watch('regionId')
  const hasUnsupportedCmekSource = isCmekSourceUnsupported(servicePlan, methods.watch('sourceProjectUsesCmek'))
  const eligibleProjects = useMemo(
    () => ownerProjects.filter((project) => !project.aws_cmek_enabled && project.type === 'tidbx'),
    [ownerProjects]
  )
  const projectOptions = useMemo(
    () => eligibleProjects.map((project) => ({ value: project.id, label: project.name })),
    [eligibleProjects]
  )

  const regionsQuery = useRegionServiceListRegions(
    {
      servicePlan,
      orgId,
      projectId: effectiveProjectId
    },
    {
      query: {
        refetchOnWindowFocus: false,
        select: (data) => ({
          ...data,
          regions: data.regions?.filter((region) => {
            const regionIdWithoutProvider = removeCloudProviderFromRegionId(region.regionId, region.cloudProvider)
            const isBackupRegion =
              region.cloudProvider === cloudProvider &&
              backup?.regions?.some((item) => regionIdWithoutProvider === item.name)

            if (!isBackupRegion || servicePlan !== Commonv1beta1ServicePlan.Essential_V2) {
              return isBackupRegion
            }

            return filterEssentialRegionsByServicePlan([region], 'Essential_V2').length > 0
          })
        })
      }
    }
  )
  const regions = useMemo(() => regionsQuery.data?.regions ?? [], [regionsQuery.data])

  useEffect(() => {
    const nextRegionId = regions[0]?.regionId ?? ''

    if (!nextRegionId) {
      if (regionId) {
        methods.setValue('regionId', '')
      }
      return
    }

    if (!regionId || !regions.some((region) => region.regionId === regionId)) {
      methods.setValue('regionId', nextRegionId)
    }
  }, [methods, regionId, regions])

  useEffect(() => {
    if (
      requestedServicePlan === Commonv1beta1ServicePlan.Premium_Reserved &&
      !isLoadingPremiumReservedFeature &&
      !isPremiumReservedEnabled
    ) {
      history.replace('/tidbs/restore-from-another-plan?plan=Premium')
    }
  }, [history, isLoadingPremiumReservedFeature, isPremiumReservedEnabled, requestedServicePlan])

  useEffect(() => {
    if (isOrgOwner || !isAnyProjectOwner) {
      return
    }

    const hasValidProjectSelection =
      !!selectedProjectId && eligibleProjects.some((project) => project.id === selectedProjectId)
    if (hasValidProjectSelection) {
      return
    }

    const nextProjectId =
      eligibleProjects.find((project) => project.id === currentProjectId)?.id || eligibleProjects[0]?.id || ''
    if (!nextProjectId) {
      return
    }

    methods.setValue('projectId', nextProjectId, { shouldValidate: true })
  }, [currentProjectId, eligibleProjects, isAnyProjectOwner, isOrgOwner, methods, selectedProjectId])

  const { instanceMaxRcu, availableTotalRcu } = useCapacityLimits({
    servicePlan,
    projectId: effectiveProjectId
  })
  const effectiveLimit = Math.min(
    instanceMaxRcu ?? PREMIUM_MAX_RCU_FALLBACK,
    availableTotalRcu ?? PREMIUM_MAX_RCU_FALLBACK
  )
  const minimumRequiredRcu = servicePlan === 'Essential_V2' ? ESSENTIAL_V2_RCU_MIN : PREMIUM_MIN_RCU
  const isQuotaInsufficient = effectiveLimit < minimumRequiredRcu

  const restore = useTidbServiceRestoreTidb()

  const onCancel = () => {
    history.push('/tidbs')
  }

  const onSubmit = methods.handleSubmit(async (data) => {
    const resolvedProjectId = isOrgOwner ? data.projectId || virtualProjectId : data.projectId

    if (!resolvedProjectId) {
      notifier.error('Missing organization or project context.')
      return
    }

    if (isCmekSourceUnsupported(servicePlan, data.sourceProjectUsesCmek)) {
      notifier.error('Restoring from a CMEK-enabled Dedicated cluster to Essential is not supported.')
      return
    }

    const isPremiumReserved = servicePlan === Commonv1beta1ServicePlan.Premium_Reserved
    const isEssentialV2 = servicePlan === Commonv1beta1ServicePlan.Essential_V2

    await restore.mutateAsync({
      data: {
        restoreMode: 'DEDICATED_SNAPSHOT',
        backupId: data.backupId,
        tidb: {
          displayName: data.name,
          servicePlan,
          cloudProvider: data.cloudProvider as V1beta1RegionCloudProvider,
          regionId: data.regionId,
          maxRcu: String(isPremiumReserved ? 0 : data.maxRcu),
          highAvailabilityType: isEssentialV2 ? V1beta2TidbHighAvailabilityType.ZONAL : data.highAvailabilityType,
          labels: {
            'tidb.cloud/project': resolvedProjectId
          },
          reservedCapacityTemplateId: isPremiumReserved ? data.reservedCapacityTemplateId : undefined
        }
      },
      params: {
        orgId,
        projectId: resolvedProjectId
      }
    })

    invalidateCapacityLimitsQueries(queryClient, servicePlan, orgId, resolvedProjectId)
    notifier.success('Restoring to a new instance...')
    history.push('/tidbs')
  })

  return (
    <PageAccessGuard id="TidbxRestoreCreate" scopeProps={{ projectId: effectiveProjectId }}>
      <FormProvider {...methods}>
        <RestoreLayout
          title="Restore from Another Plan"
          rightSection={
            <RestoreFromDedicatedSummary
              formId={formId}
              onCancel={onCancel}
              regions={regions}
              restore={restore}
              submitDisabled={
                !regions.length ||
                hasUnsupportedCmekSource ||
                isQuotaInsufficient ||
                restore.isLoading ||
                methods.formState.isSubmitting
              }
              servicePlan={servicePlan}
              projectId={effectiveProjectId}
            />
          }
        >
          <Paper component="form" id={formId} onSubmit={onSubmit} withBorder shadow="none">
            <SelectBackupSection servicePlan={servicePlan} />
            <Divider />
            <DestinationConfigSection
              regions={regions}
              projectOptions={projectOptions}
              effectiveProjectId={effectiveProjectId}
              projectOptional={isOrgOwner}
              onProjectCreated={fetchUserProfileV2}
              servicePlan={servicePlan}
            />
            {regionsQuery.isFetched && !regions.length ? (
              <>
                <Divider />
                <FormItem label="Restore Notes">
                  <Alert color="yellow" icon={<IconAlertCircle />}>
                    {servicePlan === Commonv1beta1ServicePlan.Essential_V2
                      ? 'This feature is only available for selected Essential regions. '
                      : ''}
                    No available regions match the regions of the selected backup (
                    {backup?.regions?.map((item) => item.name).join(', ') || '-'}). Please contact our support team to
                    enable {servicePlan === Commonv1beta1ServicePlan.Essential_V2 ? 'Essential' : 'Premium'} plan for
                    this region or select a different backup.
                  </Alert>
                </FormItem>
              </>
            ) : null}
          </Paper>
        </RestoreLayout>
      </FormProvider>
    </PageAccessGuard>
  )
}

export default RestoreFromDedicated