package vpcpeering

import (
	"context"
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	dmpbv1 "github.com/tidbcloud/cluster-service-ng/api/tidbcloud/dataplane-manager/v1"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	clientfake "sigs.k8s.io/controller-runtime/pkg/client/fake"

	"github.com/tidbcloud/infra-provider/regional-server/api/v1alpha1"
	bizerr "github.com/tidbcloud/infra-provider/regional-server/pkg/common/errors"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/config"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/consts"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/repository"
	infraScheme "github.com/tidbcloud/infra-provider/regional-server/pkg/scheme"
)

const vpcPeeringName = "dp-test-171bba2e"

func init() {
	_ = v1alpha1.AddToScheme(infraScheme.Scheme)
}

type fakeExternalPeeringQueryer struct {
	listByVPCFn         func(context.Context, VPCContext) ([]ExternalPeering, error)
	getByConnectionIDFn func(context.Context, VPCContext, string) (*ExternalPeering, error)
}

func (f *fakeExternalPeeringQueryer) ListByVPC(ctx context.Context, vpcCtx VPCContext) ([]ExternalPeering, error) {
	if f.listByVPCFn == nil {
		return nil, nil
	}
	return f.listByVPCFn(ctx, vpcCtx)
}

func (f *fakeExternalPeeringQueryer) GetByConnectionID(ctx context.Context, vpcCtx VPCContext, id string) (*ExternalPeering, error) {
	if f.getByConnectionIDFn == nil {
		return nil, nil
	}
	return f.getByConnectionIDFn(ctx, vpcCtx, id)
}

func newTestService(t *testing.T, queryer ExternalPeeringQueryer, objects ...client.Object) *Service {
	scheme := runtime.NewScheme()
	require.NoError(t, v1alpha1.AddToScheme(scheme))

	cli := clientfake.NewClientBuilder().
		WithScheme(scheme).
		WithObjects(objects...).
		WithStatusSubresource(&v1alpha1.VPCPeering{}).
		Build()

	cfg := config.RootConfig{
		Namespace: "default",
		ControllerConfig: config.ControllerConfig{
			Provider: consts.ProviderTypeEKS,
			RegionConfig: config.RegionConfig{
				Name: "us-west-2",
			},
		},
	}

	return &Service{
		vpcpeeringRW:    repository.NewVPCPeeringReaderWriter(cli),
		dataPlaneRW:     repository.NewDataPlaneReaderWriter(cli),
		vpcRW:           repository.NewVPCReaderWriter(cli),
		externalQueryer: queryer,
		config:          cfg,
	}
}

func existingCRObject() client.Object {
	return &v1alpha1.VPCPeering{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "default",
			Name:      vpcPeeringName,
			Labels: map[string]string{
				v1alpha1.DataPlaneIDKey: "dp-test",
			},
			Annotations: map[string]string{
				v1alpha1.AnnotationKeySourceVPCID:     "vpc-12345",
				v1alpha1.AnnotationKeySourceVPCCIDR:   "10.0.0.0/16",
				v1alpha1.AnnotationKeySourceAccountID: "123456789012",
			},
		},
		Spec: v1alpha1.VPCPeeringSpec{
			Provider: consts.ProviderTypeEKS,
			Region:   "us-west-2",
			Target: v1alpha1.Target{
				AWS: &v1alpha1.AWS{
					AccountID: "123456789012",
					VpcID:     "vpc-existing-target",
					PeerCIDR:  "10.1.0.0/16",
					Region:    "us-west-2",
				},
			},
		},
		Status: v1alpha1.VPCPeeringStatus{
			Phase:        v1alpha1.VPCPeeringPhaseActive,
			ExternalName: "pcx-dup",
		},
	}
}

func createMockDataPlane() *v1alpha1.DataPlane {
	return &v1alpha1.DataPlane{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "default",
			Name:      "dp-test",
			Labels: map[string]string{
				"tags.tidbcloud.com/tenant": "tenant-123",
			},
		},
		Spec: v1alpha1.DataPlaneSpec{
			AccountRef: v1alpha1.AccountReference{
				ProviderConfigName: "aws-provider",
				AccountID:          "123456789012",
				Role:               "regional-server-role",
			},
		},
		Status: v1alpha1.DataPlaneStatus{
			Phase: v1alpha1.DataPlanePhaseActive,
			Vpc: &v1alpha1.Reference{
				Name:      "vpc-test",
				Namespace: "default",
			},
		},
	}
}

func createMockVPC() *v1alpha1.VPC {
	return &v1alpha1.VPC{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "default",
			Name:      "vpc-test",
		},
		Spec: v1alpha1.VPCSpec{
			Provider: consts.ProviderTypeEKS,
			Region:   "us-west-2",
			CIDR:     "10.0.0.0/16",
		},
		Status: v1alpha1.VPCStatus{
			Phase: v1alpha1.VPCPhaseActive,
			VPC: v1alpha1.VPCRes{
				VPCID: "vpc-12345",
				Name:  "vpc-test",
			},
		},
	}
}

func TestService_CreateVpcPeering(t *testing.T) {
	tests := []struct {
		name           string
		setupObjects   func() []client.Object
		request        *dmpbv1.CreateVpcPeeringRequest
		wantErr        bool
		errContains    string
		validateResult func(t *testing.T, resp *dmpbv1.VpcPeering)
		validateCR     func(t *testing.T, svc *Service)
	}{
		{
			name: "success",
			setupObjects: func() []client.Object {
				return []client.Object{createMockDataPlane(), createMockVPC()}
			},
			request: &dmpbv1.CreateVpcPeeringRequest{
				DataPlaneId: "dp-test",
				VpcPeering: &dmpbv1.VpcPeering{
					Id:                   "peering-123",
					DestinationCidrBlock: "10.1.0.0/16",
					Info: &dmpbv1.VpcPeering_Aws_{
						Aws: &dmpbv1.VpcPeering_Aws{
							DestinationAccountId: "098765432109",
							DestinationVpcId:     "vpc-target",
							DestinationRegion:    "us-east-1",
						},
					},
				},
			},
			wantErr: false,
			validateResult: func(t *testing.T, resp *dmpbv1.VpcPeering) {
				assert.Equal(t, vpcPeeringName, resp.Id)
				assert.Equal(t, "10.0.0.0/16", resp.SourceCidrBlock)
				assert.Equal(t, "10.1.0.0/16", resp.DestinationCidrBlock)
				assert.Equal(t, dmpbv1.VpcPeering_STATE_UNSPECIFIED, resp.Status)
			},
			validateCR: func(t *testing.T, svc *Service) {
				peeringCR := &v1alpha1.VPCPeering{}
				err := svc.vpcpeeringRW.Get(context.Background(), client.ObjectKey{
					Namespace: "default",
					Name:      vpcPeeringName,
				}, peeringCR)
				require.NoError(t, err)
				assert.Equal(t, "vpc-12345", peeringCR.Annotations[v1alpha1.AnnotationKeySourceVPCID])
				assert.Equal(t, "10.0.0.0/16", peeringCR.Annotations[v1alpha1.AnnotationKeySourceVPCCIDR])
			},
		},
		{
			name: "dataplane not found",
			setupObjects: func() []client.Object {
				return []client.Object{}
			},
			request: &dmpbv1.CreateVpcPeeringRequest{
				DataPlaneId: "dp-notfound",
				VpcPeering: &dmpbv1.VpcPeering{
					Id: "peering-123",
				},
			},
			wantErr:     true,
			errContains: "dataplane not found",
		},
		{
			name: "missing aws info",
			setupObjects: func() []client.Object {
				return []client.Object{createMockDataPlane(), createMockVPC()}
			},
			request: &dmpbv1.CreateVpcPeeringRequest{
				DataPlaneId: "dp-test",
				VpcPeering: &dmpbv1.VpcPeering{
					Id:                   "peering-123",
					DestinationCidrBlock: "10.1.0.0/16",
				},
			},
			wantErr:     true,
			errContains: "aws info is required",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			svc := newTestService(t, nil, tt.setupObjects()...)

			resp, err := svc.CreateVpcPeering(context.Background(), tt.request)

			if tt.wantErr {
				assert.Error(t, err)
				assert.Nil(t, resp)
				if tt.errContains != "" {
					assert.Contains(t, err.Error(), tt.errContains)
				}
				return
			}

			require.NoError(t, err)
			assert.NotNil(t, resp)
			if tt.validateResult != nil {
				tt.validateResult(t, resp)
			}
			if tt.validateCR != nil {
				tt.validateCR(t, svc)
			}
		})
	}
}

func TestService_GetVpcPeering(t *testing.T) {
	tests := []struct {
		name           string
		setupObjects   func() []client.Object
		queryer        ExternalPeeringQueryer
		byocEnabled    bool
		request        *dmpbv1.GetVpcPeeringRequest
		wantErr        bool
		errContains    string
		validateResult func(t *testing.T, resp *dmpbv1.VpcPeering)
	}{
		{
			name: "success",
			setupObjects: func() []client.Object {
				dp := createMockDataPlane()
				vpc := createMockVPC()
				peeringCR := &v1alpha1.VPCPeering{
					ObjectMeta: metav1.ObjectMeta{
						Namespace: "default",
						Name:      vpcPeeringName,
						Labels: map[string]string{
							"tags.tidbcloud.com/vpcpeering-id": "peering-123",
						},
						Annotations: map[string]string{
							v1alpha1.AnnotationKeySourceVPCID:     "vpc-12345",
							v1alpha1.AnnotationKeySourceVPCCIDR:   "10.0.0.0/16",
							v1alpha1.AnnotationKeySourceAccountID: "123456789012",
						},
					},
					Spec: v1alpha1.VPCPeeringSpec{
						Provider: consts.ProviderTypeEKS,
						Region:   "us-west-2",
						Target: v1alpha1.Target{
							AWS: &v1alpha1.AWS{
								AccountID: "098765432109",
								VpcID:     "vpc-target",
								PeerCIDR:  "10.1.0.0/16",
								Region:    "us-east-1",
							},
						},
					},
					Status: v1alpha1.VPCPeeringStatus{
						Phase:        v1alpha1.VPCPeeringPhaseActive,
						ExternalName: "pcx-12345",
					},
				}
				return []client.Object{dp, vpc, peeringCR}
			},
			request: &dmpbv1.GetVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: vpcPeeringName,
			},
			wantErr: false,
			validateResult: func(t *testing.T, resp *dmpbv1.VpcPeering) {
				assert.Equal(t, vpcPeeringName, resp.Id)
				assert.Equal(t, "10.0.0.0/16", resp.SourceCidrBlock)
				assert.Equal(t, "10.1.0.0/16", resp.DestinationCidrBlock)
				assert.Equal(t, dmpbv1.VpcPeering_ACTIVE, resp.Status)

				awsInfo := resp.GetAws()
				require.NotNil(t, awsInfo)
				assert.Equal(t, "pcx-12345", awsInfo.VpcPeeringConnectionId)
				assert.Equal(t, "us-west-2", awsInfo.SourceRegion)
				assert.Equal(t, "vpc-12345", awsInfo.SourceVpcId)
				assert.Equal(t, "vpc-target", awsInfo.DestinationVpcId)
			},
		},
		{
			name: "not found",
			setupObjects: func() []client.Object {
				return []client.Object{}
			},
			request: &dmpbv1.GetVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: "peering-notfound",
			},
			wantErr:     true,
			errContains: "vpc peering not found",
		},
		{
			name: "byoc get falls back to cloud connection id",
			setupObjects: func() []client.Object {
				dp := createMockDataPlane()
				vpc := createMockVPC()
				return []client.Object{dp, vpc}
			},
			queryer: &fakeExternalPeeringQueryer{
				getByConnectionIDFn: func(ctx context.Context, vpcCtx VPCContext, id string) (*ExternalPeering, error) {
					return &ExternalPeering{
						ConnectionID: "pcx-cloud-1",
						Status:       "active",
						CurrentSide: PeeringSide{
							VpcID:     "vpc-12345",
							AccountID: "123456789012",
							Region:    "us-west-2",
							CIDR:      "10.0.0.0/16",
						},
						DestinationSide: PeeringSide{
							VpcID:     "vpc-target",
							AccountID: "098765432109",
							Region:    "us-east-1",
							CIDR:      "10.1.0.0/16",
						},
					}, nil
				},
			},
			byocEnabled: true,
			request: &dmpbv1.GetVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: "pcx-cloud-1",
			},
			validateResult: func(t *testing.T, resp *dmpbv1.VpcPeering) {
				require.NotNil(t, resp)
				assert.Equal(t, "pcx-cloud-1", resp.Id)
				assert.Equal(t, dmpbv1.VpcPeering_ACTIVE, resp.Status)
				assert.Equal(t, "10.0.0.0/16", resp.SourceCidrBlock)
				assert.Equal(t, "10.1.0.0/16", resp.DestinationCidrBlock)
				assert.Equal(t, "pcx-cloud-1", resp.GetAws().VpcPeeringConnectionId)
			},
		},
		{
			name: "byoc get preserves external query errors",
			setupObjects: func() []client.Object {
				return []client.Object{createMockDataPlane(), createMockVPC()}
			},
			queryer: &fakeExternalPeeringQueryer{
				getByConnectionIDFn: func(ctx context.Context, vpcCtx VPCContext, id string) (*ExternalPeering, error) {
					return nil, fmt.Errorf("throttling")
				},
			},
			byocEnabled: true,
			request: &dmpbv1.GetVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: "pcx-cloud-err",
			},
			wantErr:     true,
			errContains: "query external vpc peering error",
		},
		{
			name: "with status only",
			setupObjects: func() []client.Object {
				peeringCR := &v1alpha1.VPCPeering{
					ObjectMeta: metav1.ObjectMeta{
						Namespace: "default",
						Name:      vpcPeeringName,
						Annotations: map[string]string{
							v1alpha1.AnnotationKeySourceVPCCIDR: "10.0.0.0/16",
						},
					},
					Spec: v1alpha1.VPCPeeringSpec{
						Provider: consts.ProviderTypeEKS,
						Target: v1alpha1.Target{
							AWS: &v1alpha1.AWS{
								PeerCIDR: "10.1.0.0/16",
							},
						},
					},
					Status: v1alpha1.VPCPeeringStatus{
						Phase: v1alpha1.VPCPeeringPhasePending,
					},
				}
				return []client.Object{peeringCR}
			},
			request: &dmpbv1.GetVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: vpcPeeringName,
			},
			wantErr: false,
			validateResult: func(t *testing.T, resp *dmpbv1.VpcPeering) {
				assert.Equal(t, "10.0.0.0/16", resp.SourceCidrBlock) // From annotation
				assert.Equal(t, dmpbv1.VpcPeering_PENDING, resp.Status)
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			svc := newTestService(t, tt.queryer, tt.setupObjects()...)
			if tt.byocEnabled {
				svc.config.BYOC.BYOCPrivateLink.ControlPlaneVPCID = "control-plane-vpc"
			}

			resp, err := svc.GetVpcPeering(context.Background(), tt.request)

			if tt.wantErr {
				assert.Error(t, err)
				assert.Nil(t, resp)
				if tt.errContains != "" {
					assert.Contains(t, err.Error(), tt.errContains)
				}
				if tt.name == "byoc get preserves external query errors" {
					assert.False(t, bizerr.Is(err, bizerr.ResourceNotFound))
				}
				return
			}

			require.NoError(t, err)
			assert.NotNil(t, resp)
			if tt.validateResult != nil {
				tt.validateResult(t, resp)
			}
		})
	}
}

func TestService_ListVpcPeerings(t *testing.T) {
	svc := newTestService(t, nil, &v1alpha1.VPCPeering{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "default",
			Name:      vpcPeeringName,
			Annotations: map[string]string{
				v1alpha1.AnnotationKeySourceVPCID:     "vpc-12345",
				v1alpha1.AnnotationKeySourceVPCCIDR:   "10.0.0.0/16",
				v1alpha1.AnnotationKeySourceAccountID: "123456789012",
			},
			Labels: map[string]string{
				v1alpha1.DataPlaneIDKey: "dp-test",
			},
		},
		Spec: v1alpha1.VPCPeeringSpec{
			Provider: consts.ProviderTypeEKS,
			Region:   "us-west-2",
			Target: v1alpha1.Target{
				AWS: &v1alpha1.AWS{
					AccountID: "098765432109",
					VpcID:     "vpc-target",
					PeerCIDR:  "10.1.0.0/16",
					Region:    "us-east-1",
				},
			},
		},
		Status: v1alpha1.VPCPeeringStatus{
			Phase:        v1alpha1.VPCPeeringPhaseActive,
			ExternalName: "pcx-12345",
		},
	})

	resp, err := svc.ListVpcPeerings(context.Background(), &dmpbv1.ListVpcPeeringsRequest{
		DataPlaneId: "dp-test",
	})

	require.NoError(t, err)
	require.Len(t, resp.VpcPeerings, 1)

	awsInfo := resp.VpcPeerings[0].GetAws()
	require.NotNil(t, awsInfo)
	assert.Equal(t, "us-west-2", awsInfo.SourceRegion)
	assert.Equal(t, "us-east-1", awsInfo.DestinationRegion)
	assert.Equal(t, "vpc-12345", awsInfo.SourceVpcId)
	assert.Equal(t, "vpc-target", awsInfo.DestinationVpcId)
}

func TestService_ListVpcPeerings_BYOCSupplementAndFilterO11YCloudPeering(t *testing.T) {
	svc := newTestService(t, &fakeExternalPeeringQueryer{
		listByVPCFn: func(ctx context.Context, vpcCtx VPCContext) ([]ExternalPeering, error) {
			return []ExternalPeering{
				{
					ConnectionID: "pcx-dup",
					Status:       "active",
					CurrentSide: PeeringSide{
						VpcID:     "vpc-12345",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.0.0.0/16",
					},
					DestinationSide: PeeringSide{
						VpcID:     "vpc-existing-target",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.1.0.0/16",
					},
				},
				{
					ConnectionID: "pcx-filtered",
					Status:       "active",
					CurrentSide: PeeringSide{
						VpcID:     "vpc-12345",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.0.0.0/16",
					},
					DestinationSide: PeeringSide{
						VpcID:     "vpc-o11y",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.2.0.0/16",
					},
				},
				{
					ConnectionID: "pcx-keep-cross-account",
					Status:       "active",
					CurrentSide: PeeringSide{
						VpcID:     "vpc-12345",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.0.0.0/16",
					},
					DestinationSide: PeeringSide{
						VpcID:     "vpc-cross",
						AccountID: "210987654321",
						Region:    "us-east-1",
						CIDR:      "10.3.0.0/16",
					},
				},
			}, nil
		},
	}, createMockDataPlane(), createMockVPC(), existingCRObject())

	svc.config.BYOC.BYOCPrivateLink.ControlPlaneVPCID = "control-plane-vpc"
	svc.config.O11Y.VPCID = "vpc-o11y"

	resp, err := svc.ListVpcPeerings(context.Background(), &dmpbv1.ListVpcPeeringsRequest{DataPlaneId: "dp-test"})
	require.NoError(t, err)
	require.Len(t, resp.VpcPeerings, 2)
	assert.Equal(t, []string{vpcPeeringName, "pcx-keep-cross-account"}, []string{resp.VpcPeerings[0].Id, resp.VpcPeerings[1].Id})
}

func TestService_ListVpcPeerings_FiltersExistingCRO11YPeering(t *testing.T) {
	svc := newTestService(t, &fakeExternalPeeringQueryer{
		listByVPCFn: func(ctx context.Context, vpcCtx VPCContext) ([]ExternalPeering, error) {
			return nil, nil
		},
	}, createMockDataPlane(), createMockVPC(), existingCRObject())

	svc.config.BYOC.BYOCPrivateLink.ControlPlaneVPCID = "control-plane-vpc"
	svc.config.O11Y.VPCID = "vpc-existing-target"

	resp, err := svc.ListVpcPeerings(context.Background(), &dmpbv1.ListVpcPeeringsRequest{DataPlaneId: "dp-test"})
	require.NoError(t, err)
	require.Empty(t, resp.VpcPeerings)
}

func TestService_ListVpcPeerings_DoesNotFilterWhenO11YVPCUnset(t *testing.T) {
	svc := newTestService(t, &fakeExternalPeeringQueryer{
		listByVPCFn: func(ctx context.Context, vpcCtx VPCContext) ([]ExternalPeering, error) {
			return []ExternalPeering{
				{
					ConnectionID: "pcx-o11y",
					Status:       "active",
					CurrentSide: PeeringSide{
						VpcID:     "vpc-12345",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.0.0.0/16",
					},
					DestinationSide: PeeringSide{
						VpcID:     "vpc-o11y",
						AccountID: "123456789012",
						Region:    "us-west-2",
						CIDR:      "10.2.0.0/16",
					},
				},
			}, nil
		},
	}, createMockDataPlane(), createMockVPC(), existingCRObject())

	svc.config.BYOC.BYOCPrivateLink.ControlPlaneVPCID = "control-plane-vpc"

	resp, err := svc.ListVpcPeerings(context.Background(), &dmpbv1.ListVpcPeeringsRequest{DataPlaneId: "dp-test"})
	require.NoError(t, err)
	require.Len(t, resp.VpcPeerings, 2)
	assert.Equal(t, []string{vpcPeeringName, "pcx-o11y"}, []string{resp.VpcPeerings[0].Id, resp.VpcPeerings[1].Id})
}

func TestService_DeleteVpcPeering(t *testing.T) {
	tests := []struct {
		name         string
		setupObjects func() []client.Object
		request      *dmpbv1.DeleteVpcPeeringRequest
		wantErr      bool
		errContains  string
		validateCR   func(t *testing.T, svc *Service)
	}{
		{
			name: "success",
			setupObjects: func() []client.Object {
				peeringCR := &v1alpha1.VPCPeering{
					ObjectMeta: metav1.ObjectMeta{
						Namespace: "default",
						Name:      "dp-test-peering-123",
					},
					Spec: v1alpha1.VPCPeeringSpec{
						Provider: consts.ProviderTypeEKS,
					},
				}
				return []client.Object{peeringCR}
			},
			request: &dmpbv1.DeleteVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: "peering-123",
			},
			wantErr: false,
			validateCR: func(t *testing.T, svc *Service) {
				deletedCR := &v1alpha1.VPCPeering{}
				err := svc.vpcpeeringRW.Get(context.Background(), client.ObjectKey{
					Namespace: "default",
					Name:      vpcPeeringName,
				}, deletedCR)
				assert.True(t, apierrors.IsNotFound(err))
			},
		},
		{
			name: "already deleted - idempotent",
			setupObjects: func() []client.Object {
				return []client.Object{}
			},
			request: &dmpbv1.DeleteVpcPeeringRequest{
				DataPlaneId:  "dp-test",
				VpcPeeringId: "peering-123",
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			svc := newTestService(t, nil, tt.setupObjects()...)

			resp, err := svc.DeleteVpcPeering(context.Background(), tt.request)

			if tt.wantErr {
				assert.Error(t, err)
				assert.Nil(t, resp)
				if tt.errContains != "" {
					assert.Contains(t, err.Error(), tt.errContains)
				}
				return
			}

			require.NoError(t, err)
			assert.NotNil(t, resp)
			if tt.validateCR != nil {
				tt.validateCR(t, svc)
			}
		})
	}
}

func TestGetVPCPeeringName(t *testing.T) {
	tests := []struct {
		name            string
		dataplaneID     string
		targetVPC       string
		expectedPattern string
	}{
		{
			name:            "normal AWS VPC ID",
			dataplaneID:     "dp-test",
			targetVPC:       "vpc-12345abcdef",
			expectedPattern: "dp-test-[a-f0-9]{8}",
		},
		{
			name:            "different VPC IDs should produce different hashes",
			dataplaneID:     "dp-test",
			targetVPC:       "vpc-different",
			expectedPattern: "dp-test-[a-f0-9]{8}",
		},
		{
			name:            "same VPC ID should produce same hash",
			dataplaneID:     "dp-test",
			targetVPC:       "vpc-sameid",
			expectedPattern: "dp-test-[a-f0-9]{8}",
		},
		{
			name:            "complex VPC ID with special characters",
			dataplaneID:     "dp-test",
			targetVPC:       "vpc-12345_abcdef-67890",
			expectedPattern: "dp-test-[a-f0-9]{8}",
		},
	}

	// Store hashes for consistency check
	hashes := make(map[string]string)

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			name := getVPCPeeringName(tt.dataplaneID, tt.targetVPC)

			// Check pattern matches
			assert.Regexp(t, tt.expectedPattern, name)

			// Check format: dataplaneID + "-" + 8-char hash
			assert.True(t, len(name) > len(tt.dataplaneID)+1)
			assert.Equal(t, tt.dataplaneID+"-", name[:len(tt.dataplaneID)+1])
			hashPart := name[len(tt.dataplaneID)+1:]
			assert.Equal(t, 8, len(hashPart))
			assert.Regexp(t, "^[a-f0-9]{8}$", hashPart)

			// Store for consistency check
			key := fmt.Sprintf("%s-%s", tt.dataplaneID, tt.targetVPC)
			if storedHash, exists := hashes[key]; exists {
				assert.Equal(t, storedHash, name, "Same input should produce same hash")
			} else {
				hashes[key] = name
			}
		})
	}

	// Test that different VPC IDs produce different hashes
	hash1 := getVPCPeeringName("dp-test", "vpc-first")
	hash2 := getVPCPeeringName("dp-test", "vpc-second")
	assert.NotEqual(t, hash1, hash2, "Different VPC IDs should produce different hashes")

	// Test that same VPC ID produces same hash (deterministic)
	hash3 := getVPCPeeringName("dp-test", "vpc-first")
	assert.Equal(t, hash1, hash3, "Same VPC ID should produce same hash")
}

func TestConvertExternalStatusToPB(t *testing.T) {
	tests := []struct {
		name   string
		status string
		want   dmpbv1.VpcPeering_Status
	}{
		{
			name:   "deleting is not failed",
			status: "deleting",
			want:   dmpbv1.VpcPeering_STATE_UNSPECIFIED,
		},
		{
			name:   "deleted is not failed",
			status: "deleted",
			want:   dmpbv1.VpcPeering_STATE_UNSPECIFIED,
		},
		{
			name:   "failed remains failed",
			status: "failed",
			want:   dmpbv1.VpcPeering_FAILED,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			assert.Equal(t, tt.want, convertExternalStatusToPB(tt.status))
		})
	}
}