import { useLocation, useParams } from 'react-router-dom'

import { HeroComponent, isHeroQueryReady } from 'dbaas/components/Measurement'
import { DelayedPageLoader } from 'dbaas/components/Placeholder'
import { ESSENTIAL_RCU_MIN } from 'dbaas/screens/ClustersV2/new/Essential/shared/capacity'
import {
  useBackupRestoreServiceGetRecycledInstance,
  useBackupRestoreServiceListRecycledInstanceBackups
} from 'dbaas/services/api-clients/legacy/serverless'
import useStores from 'dbaas/stores/useStores'

import RestoreForServerlessNextGen from './NextGen'

export default function RestoreForEssentialFromRecycleBinPage() {
  const location = useLocation()
  const { id: clusterId } = useParams<{ id: string }>()
  const {
    store: {
      lastVisitLocation: { orgId }
    }
  } = useStores()

  const params = new URLSearchParams(location.search)
  const backupId = params.get('backup_id') ?? ''
  const perPage = 20

  const {
    data: backupsData,
    isLoading: isLoadingBackups,
    isFetched: isBackupsFetched,
    isError: isBackupsError
  } = useBackupRestoreServiceListRecycledInstanceBackups(
    orgId,
    clusterId,
    { page_size: perPage, page_token: '', order_by: 'backup_time desc' },
    { query: { enabled: !!orgId && !!clusterId } }
  )

  const hero = <HeroComponent ready={isHeroQueryReady({ isFetched: isBackupsFetched, isError: isBackupsError })} />

  const { data: deletedCluster, isLoading: isLoadingCluster } = useBackupRestoreServiceGetRecycledInstance(
    orgId,
    clusterId
  )

  if (isLoadingCluster || isLoadingBackups) {
    return (
      <>
        {hero}
        <DelayedPageLoader />
      </>
    )
  }

  const backup = (backupsData?.backups ?? []).find((b) => b.backup_id === backupId)

  if (!backup) {
    return (
      <>
        {hero}
        <DelayedPageLoader />
      </>
    )
  }

  // construct a minimal SharedCluster-like object expected by RestoreForServerlessNextGen
  const cluster: any = {
    id: deletedCluster?.cluster_id,
    name: deletedCluster?.display_name,
    provider: deletedCluster?.provider || '',
    region: deletedCluster?.region || '',
    regionId: deletedCluster?.region || '',
    servicePlan: 'Essential',
    state: undefined,
    serverless: {
      region: {
        cloudProvider: deletedCluster?.provider || '',
        name: deletedCluster?.region || ''
      },
      servicePlan: 'Essential',
      encryptionConfig: {
        enhancedEncryptionEnabled: deletedCluster?.enhanced_encryption_enabled ?? false
      }
    },
    autoScaling: {
      maxRcu: 4000,
      minRcu: ESSENTIAL_RCU_MIN
    },
    computed: {
      loading: false,
      isStarter: false,
      isEssential: true,
      clusterType: 'Serverless',
      ready: true,
      projectId: deletedCluster?.project_id || ''
    }
  }

  return (
    <>
      {hero}
      <RestoreForServerlessNextGen cluster={cluster} />
    </>
  )
}