package resourcepool

import (
	"context"
	"strconv"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	clusterngv1beta "github.com/tidbcloud/cluster-service-ng/api/cluster-service-ng/v1beta"
	"go.uber.org/mock/gomock"
	"google.golang.org/protobuf/types/known/timestamppb"

	globalcommonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	globalngv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/nextgen/v1"
	mockregionalserver "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/adapter/regionalserver/mock_regionalserver"
	"github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/entity"
	regionrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/region"
	mockregion "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/region/mock_region"
	resourcepoolrepo "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/resourcepool"
	mockresourcepool "github.com/tidbcloud/tidb-management-service/nextgen-global-service/domain/repository/resourcepool/mock_resourcepool"
)

func TestBackfillResourcePoolMetadataDryRunUsesBoundedSeekPage(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	createdAt := time.Date(2026, time.July, 23, 8, 0, 0, 0, time.UTC)
	first := legacyBackfillResourcePool(101, 42, createdAt)
	second := legacyBackfillResourcePool(100, 42, createdAt.Add(-time.Second))
	resourcePools.EXPECT().
		Query(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, filter *resourcepoolrepo.Filter) ([]*entity.ResourcePool, int64, error) {
			require.Equal(t, int64(2), filter.PageSize)
			require.Nil(t, filter.Cursor)
			require.Equal(t, []uint64{42}, filter.OwnerIds)
			return []*entity.ResourcePool{first, second}, 2, nil
		})
	regions.EXPECT().
		SelectRegion(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, filter regionrepo.Filter) (*entity.Region, error) {
			require.Equal(t, uint64(42), filter.TenantId)
			require.Equal(t, globalcommonv1.ServicePlan_BYOC, filter.ServicePlan)
			return &entity.Region{}, nil
		})
	regional.EXPECT().
		GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		DoAndReturn(func(
			_ context.Context,
			_ *entity.Region,
			request *clusterngv1beta.GetSharedPoolRequest,
		) (*clusterngv1beta.SharedPool, error) {
			require.Equal(t, "101", request.GetSharedPoolId())
			sharedPool := auditableBackfillSharedPool(clusterngv1beta.CapacityMode_RCU_DRIVEN)
			sharedPool.CloudResourceTags = map[string]string{"team": "database"}
			return sharedPool, nil
		})
	resourcePools.EXPECT().
		HasLiveNormalizedName(gomock.Any(), uint64(42), "pool-101", uint64(101)).
		Return(false, nil)
	resourcePools.EXPECT().
		InspectLiveCIDROverlapForBackfill(
			gomock.Any(),
			uint64(42),
			globalcommonv1.CloudProvider_AWS,
			globalcommonv1.Region_AWS_US_EAST_1,
			[]byte{10, 0, 0, 0},
			[]byte{10, 0, 0, 255},
			uint64(101),
		).
		Return(false, nil, nil)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize:       1,
		OrganizationID: 42,
		DryRun:         true,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.Scanned)
	require.Equal(t, int64(1), report.Candidates)
	require.NotEmpty(t, report.NextCursor)
	require.False(t, report.ScanComplete)
	require.False(t, report.ReadyForRollout)

	cursor, hasCursor, cursorErr := parseMetadataBackfillCursor(report.NextCursor)
	require.NoError(t, cursorErr)
	require.True(t, hasCursor)
	require.Equal(t, uint64(101), cursor.ID)
	require.Equal(t, createdAt, cursor.CreatedAt)
}

func TestBackfillResourcePoolMetadataSkipsConflictWinnersAndAuditsTopology(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		transaction:      resourcePoolPassthroughTransactioner{},
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(202, 84, time.Date(2026, time.July, 23, 9, 0, 0, 0, time.UTC))
	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).Return(&entity.Region{}, nil)
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(auditableBackfillSharedPool(clusterngv1beta.CapacityMode_TOPOLOGY_DRIVEN), nil)
	gomock.InOrder(
		resourcePools.EXPECT().LockOrganizationNamespace(gomock.Any(), uint64(84)).Return(nil),
		resourcePools.EXPECT().LoadForUpdate(gomock.Any(), uint64(202), false).Return(pool, nil),
		resourcePools.EXPECT().
			HasLiveNormalizedName(gomock.Any(), uint64(84), "pool-202", uint64(202)).
			Return(true, nil),
		resourcePools.EXPECT().
			InspectLiveCIDROverlapForBackfill(
				gomock.Any(),
				uint64(84),
				globalcommonv1.CloudProvider_AWS,
				globalcommonv1.Region_AWS_US_EAST_1,
				[]byte{10, 0, 0, 0},
				[]byte{10, 0, 0, 255},
				uint64(202),
			).
			Return(true, nil, nil),
		resourcePools.EXPECT().
			BackfillMetadata(gomock.Any(), gomock.Any()).
			DoAndReturn(func(
				_ context.Context,
				patch *resourcepoolrepo.MetadataBackfillPatch,
			) (resourcepoolrepo.MetadataBackfillResult, error) {
				require.Nil(t, patch.NormalizedName)
				require.Empty(t, patch.CIDRStartIPv4)
				require.Empty(t, patch.CIDREndIPv4)
				require.NotNil(t, patch.LifecycleState)
				require.Equal(t, globalngv1.ResourcePool_ACTIVE, *patch.LifecycleState)
				require.NotNil(t, patch.VcpuLimitMode)
				require.Equal(t, globalngv1.ResourcePool_LIMITED, *patch.VcpuLimitMode)
				return resourcepoolrepo.MetadataBackfillResult{
					LifecycleState: true,
					VcpuLimitMode:  true,
				}, nil
			}),
	)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   false,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.DuplicateNames)
	require.Equal(t, int64(1), report.CIDROverlaps)
	require.Equal(t, int64(1), report.TopologyDrivenPools)
	require.Equal(t, int64(1), report.Candidates)
	require.Equal(t, int64(1), report.UpdatedRecords)
	require.Equal(t, int64(2), report.UpdatedFields)
	require.False(t, report.ReadyForRollout)
}

func TestBackfillResourcePoolMetadataBackfillsPremiumLifecycleWithoutCIDRChecks(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		transaction:      resourcePoolPassthroughTransactioner{},
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(204, 85, time.Date(2026, time.July, 23, 9, 0, 0, 0, time.UTC))
	pool.ServicePlan = globalcommonv1.ServicePlan_Premium
	pool.Cidr = "not-a-cidr"
	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, filter regionrepo.Filter) (*entity.Region, error) {
			require.Equal(t, globalcommonv1.ServicePlan_Premium, filter.ServicePlan)
			return &entity.Region{}, nil
		})
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(&clusterngv1beta.SharedPool{Phase: clusterngv1beta.SharedPool_AVAILABLE}, nil)
	gomock.InOrder(
		resourcePools.EXPECT().LockOrganizationNamespace(gomock.Any(), uint64(85)).Return(nil),
		resourcePools.EXPECT().LoadForUpdate(gomock.Any(), uint64(204), false).Return(pool, nil),
		resourcePools.EXPECT().HasLiveNormalizedName(
			gomock.Any(), uint64(85), "pool-204", uint64(204),
		).Return(false, nil),
		resourcePools.EXPECT().BackfillMetadata(gomock.Any(), gomock.Any()).
			DoAndReturn(func(
				_ context.Context,
				patch *resourcepoolrepo.MetadataBackfillPatch,
			) (resourcepoolrepo.MetadataBackfillResult, error) {
				require.Nil(t, patch.VcpuLimitMode)
				require.NotNil(t, patch.LifecycleState)
				require.NotNil(t, patch.NormalizedName)
				return resourcepoolrepo.MetadataBackfillResult{
					NormalizedName: true,
					LifecycleState: true,
				}, nil
			}),
	)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   false,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.Candidates)
	require.Equal(t, int64(1), report.UpdatedRecords)
	require.Zero(t, report.InvalidCIDRs)
	require.Zero(t, report.CIDROverlaps)
	require.Zero(t, report.TopologyDrivenPools)
}

func TestBackfillResourcePoolMetadataIncludesSharedPoolsWithoutNameChecks(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	createdAt := time.Date(2026, time.July, 23, 9, 30, 0, 0, time.UTC)
	pool := &entity.ResourcePool{
		ResourcePool: &globalngv1.ResourcePool{
			Id:             205,
			Name:           " shared-essential-v2 ",
			OwnerType:      globalngv1.ResourcePool_SHARED,
			ServicePlan:    globalcommonv1.ServicePlan_Essential_V2,
			CreateTime:     timestamppb.New(createdAt),
			LifecycleState: globalngv1.ResourcePool_LIFECYCLE_STATE_UNSPECIFIED,
		},
	}
	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, filter *resourcepoolrepo.Filter) ([]*entity.ResourcePool, int64, error) {
			require.Zero(t, filter.OwnerType)
			return []*entity.ResourcePool{pool}, 1, nil
		})
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, filter regionrepo.Filter) (*entity.Region, error) {
			require.Zero(t, filter.TenantId)
			require.Equal(t, globalcommonv1.ServicePlan_Essential_V2, filter.ServicePlan)
			return &entity.Region{}, nil
		})
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(&clusterngv1beta.SharedPool{Phase: clusterngv1beta.SharedPool_AVAILABLE}, nil)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   true,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.Scanned)
	require.Equal(t, int64(1), report.Candidates)
	require.Zero(t, report.DuplicateNames)
	require.Zero(t, report.InvalidCIDRs)
}

func TestBackfillResourcePoolMetadataRepeatedRunIsIdempotentAndReady(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		transaction:      resourcePoolPassthroughTransactioner{},
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(303, 126, time.Date(2026, time.July, 23, 10, 0, 0, 0, time.UTC))
	pool.NormalizedName = "pool-303"
	pool.CanonicalCIDR = &entity.IPv4Range{
		Start: [4]byte{10, 0, 0, 0},
		End:   [4]byte{10, 0, 0, 255},
	}
	pool.LifecycleState = globalngv1.ResourcePool_ACTIVE
	pool.VcpusLimit = 0
	pool.CloudResourceTags = map[string]string{}

	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).Return(&entity.Region{}, nil)
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(auditableBackfillSharedPool(clusterngv1beta.CapacityMode_RCU_DRIVEN), nil)
	gomock.InOrder(
		resourcePools.EXPECT().LockOrganizationNamespace(gomock.Any(), uint64(126)).Return(nil),
		resourcePools.EXPECT().LoadForUpdate(gomock.Any(), uint64(303), false).Return(pool, nil),
	)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   false,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.AlreadyComplete)
	require.Zero(t, report.Candidates)
	require.Zero(t, report.UpdatedRecords)
	require.True(t, report.ScanComplete)
	require.True(t, report.ReadyForRollout)
}

func TestBackfillResourcePoolMetadataAuditsInvalidProjectionAndLegacyWrite(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(404, 168, time.Date(2026, time.July, 23, 11, 0, 0, 0, time.UTC))
	pool.NormalizedName = "pool-404"
	pool.CanonicalCIDR = &entity.IPv4Range{
		Start: [4]byte{10, 0, 0, 0},
		End:   [4]byte{10, 0, 0, 255},
	}
	pool.LifecycleState = globalngv1.ResourcePool_ACTIVE
	pool.VcpusLimit = 0
	pool.CloudResourceTags = map[string]string{}

	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).Return(&entity.Region{}, nil)
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(&clusterngv1beta.SharedPool{
			CapacityMode: clusterngv1beta.CapacityMode_RCU_DRIVEN,
			Phase:        clusterngv1beta.SharedPool_AVAILABLE,
			ComponentGroups: []*clusterngv1beta.Component{{
				ComponentType: clusterngv1beta.ComponentType_TIFLASH_WRITE,
				NodeQuota:     &clusterngv1beta.NodeQuota{NodeCount: 1},
			}},
		}, nil)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   true,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.InvalidCapacityShapes)
	require.Equal(t, int64(1), report.LegacyWriteComponents)
	require.Equal(t, int64(1), report.AlreadyComplete)
	require.False(t, report.ReadyForRollout)
}

func TestBackfillResourcePoolMetadataPersistsEmptyRegionalTagsAsJSONMap(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		transaction:      resourcePoolPassthroughTransactioner{},
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(505, 210, time.Date(2026, time.July, 23, 12, 0, 0, 0, time.UTC))
	pool.NormalizedName = "pool-505"
	pool.CanonicalCIDR = &entity.IPv4Range{
		Start: [4]byte{10, 0, 0, 0},
		End:   [4]byte{10, 0, 0, 255},
	}
	pool.LifecycleState = globalngv1.ResourcePool_ACTIVE
	pool.VcpusLimit = 0

	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).Return(&entity.Region{}, nil)
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(auditableBackfillSharedPool(clusterngv1beta.CapacityMode_RCU_DRIVEN), nil)
	gomock.InOrder(
		resourcePools.EXPECT().LockOrganizationNamespace(gomock.Any(), uint64(210)).Return(nil),
		resourcePools.EXPECT().LoadForUpdate(gomock.Any(), uint64(505), false).Return(pool, nil),
		resourcePools.EXPECT().
			BackfillMetadata(gomock.Any(), gomock.Any()).
			DoAndReturn(func(
				_ context.Context,
				patch *resourcepoolrepo.MetadataBackfillPatch,
			) (resourcepoolrepo.MetadataBackfillResult, error) {
				require.True(t, patch.BackfillTags)
				require.NotNil(t, patch.CloudResourceTags)
				require.Empty(t, patch.CloudResourceTags)
				return resourcepoolrepo.MetadataBackfillResult{CloudResourceTags: true}, nil
			}),
	)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   false,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.Candidates)
	require.Equal(t, int64(1), report.UpdatedRecords)
	require.False(t, report.ReadyForRollout)
}

func TestBackfillResourcePoolMetadataReportsInvalidCIDRPeerWithoutAborting(t *testing.T) {
	ctrl := gomock.NewController(t)
	resourcePools := mockresourcepool.NewMockRepo(ctrl)
	regions := mockregion.NewMockRepo(ctrl)
	regional := mockregionalserver.NewMockClient(ctrl)
	service := &serviceImpl{
		resourcePoolRepo: resourcePools,
		regionRepo:       regions,
		regionalCli:      regional,
	}

	pool := legacyBackfillResourcePool(606, 252, time.Date(2026, time.July, 23, 13, 0, 0, 0, time.UTC))
	pool.NormalizedName = "pool-606"
	pool.LifecycleState = globalngv1.ResourcePool_ACTIVE
	pool.VcpusLimit = 0
	pool.CloudResourceTags = map[string]string{}

	resourcePools.EXPECT().Query(gomock.Any(), gomock.Any()).
		Return([]*entity.ResourcePool{pool}, int64(1), nil)
	regions.EXPECT().SelectRegion(gomock.Any(), gomock.Any()).Return(&entity.Region{}, nil)
	regional.EXPECT().GetSharedPool(gomock.Any(), gomock.Any(), gomock.Any()).
		Return(auditableBackfillSharedPool(clusterngv1beta.CapacityMode_RCU_DRIVEN), nil)
	resourcePools.EXPECT().
		InspectLiveCIDROverlapForBackfill(
			gomock.Any(),
			uint64(252),
			globalcommonv1.CloudProvider_AWS,
			globalcommonv1.Region_AWS_US_EAST_1,
			[]byte{10, 0, 0, 0},
			[]byte{10, 0, 0, 255},
			uint64(606),
		).
		Return(false, []uint64{999}, nil)

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		DryRun:   true,
	})

	require.NoError(t, err)
	require.Equal(t, int64(1), report.InvalidCIDRs)
	require.Equal(t, []uint64{999}, report.InvalidCIDRResourcePoolIDs)
	require.Equal(t, int64(1), report.AlreadyComplete)
	require.False(t, report.ReadyForRollout)
}

func TestBackfillResourcePoolMetadataRejectsInvalidCursor(t *testing.T) {
	service := &serviceImpl{}

	report, err := service.BackfillResourcePoolMetadata(t.Context(), MetadataBackfillRequest{
		PageSize: 10,
		Cursor:   "not-a-cursor",
		DryRun:   true,
	})

	require.Error(t, err)
	require.Nil(t, report)
}

func auditableBackfillSharedPool(mode clusterngv1beta.CapacityMode) *clusterngv1beta.SharedPool {
	return &clusterngv1beta.SharedPool{
		CapacityMode: mode,
		Phase:        clusterngv1beta.SharedPool_AVAILABLE,
		ComponentGroups: []*clusterngv1beta.Component{{
			ComponentType: clusterngv1beta.ComponentType_TIKV,
			NodeQuota: &clusterngv1beta.NodeQuota{
				NodeSpec:  &clusterngv1beta.NodeSpec{Cpu: 8, MemoryGi: 32},
				NodeCount: 3,
			},
		}},
	}
}

func TestBackfillLifecycleFromRegionalPhaseDoesNotClassifyUnavailableAsFailed(t *testing.T) {
	state, err := backfillLifecycleFromRegionalPhase(clusterngv1beta.SharedPool_UNAVAILABLE)

	require.Error(t, err)
	require.Equal(t, globalngv1.ResourcePool_LIFECYCLE_STATE_UNSPECIFIED, state)
}

func legacyBackfillResourcePool(id, organizationID uint64, createdAt time.Time) *entity.ResourcePool {
	return &entity.ResourcePool{
		ResourcePool: &globalngv1.ResourcePool{
			Id:             id,
			Name:           " Pool-" + strconv.FormatUint(id, 10) + " ",
			OwnerType:      globalngv1.ResourcePool_ORGANIZATION,
			OwnerId:        organizationID,
			Cidr:           "10.0.0.0/24",
			ServicePlan:    globalcommonv1.ServicePlan_BYOC,
			VcpusLimit:     16,
			VcpuLimitMode:  globalngv1.ResourcePool_INHERITED,
			ProviderId:     globalcommonv1.CloudProvider_AWS,
			RegionId:       globalcommonv1.Region_AWS_US_EAST_1,
			CreateTime:     timestamppb.New(createdAt),
			LifecycleState: globalngv1.ResourcePool_LIFECYCLE_STATE_UNSPECIFIED,
		},
	}
}