package adapterimpl

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"sync"
	"time"

	"github.com/go-resty/resty/v2"
	"github.com/tidbcloud/pkgv2/db"
	"github.com/tidbcloud/tiinf/monitor/tilog"
	"go.uber.org/zap"
	"google.golang.org/protobuf/encoding/protojson"
	"google.golang.org/protobuf/proto"

	globalcommonv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/common/v1"
	globalserverlessv1 "github.com/tidbcloud/tidb-management-service/api/spec/global/serverless/v1"
	regionalserverlessv1 "github.com/tidbcloud/tidb-management-service/api/spec/regional/serverless/v1"
	"github.com/tidbcloud/tidb-management-service/serverless-global-service/domain/adapter"
	"github.com/tidbcloud/tidb-management-service/serverless-global-service/domain/entity"
	"github.com/tidbcloud/tidb-management-service/serverless-global-service/domain/repository"
	svccvt "github.com/tidbcloud/tidb-management-service/serverless-global-service/domain/service/cvt"
	adaptercvt "github.com/tidbcloud/tidb-management-service/serverless-global-service/infra/adapterimpl/cvt"
	"github.com/tidbcloud/tidb-management-service/serverless-global-service/pkg/config"
	"github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	"github.com/tidbcloud/tidb-management-service/utilities/httputil"
)

const (
	idPathParameter         = "id"
	tenantIdQueryParameter  = "tenant_id"
	projectIdQueryParameter = "project_id"
)

var (
	// marshalOptions is a configurable JSON format marshaller.
	// marshalOptions = protojson.MarshalOptions{
	// 	// UseProtoNames:   true,
	// 	EmitUnpopulated: true,
	// }

	// unmarshalOptions is a configurable JSON format parser.
	unmarshalOptions = protojson.UnmarshalOptions{
		DiscardUnknown: true,
	}
)
var operationMap = map[string]string{
	"DescribeRegion":              "/serverless/regional/v1/desc",
	"CreateCluster":               fmt.Sprintf("/serverless/regional/v1/clusters/{%s}", idPathParameter),
	"DeleteCluster":               fmt.Sprintf("/serverless/regional/v1/clusters/{%s}", idPathParameter),
	"ListCluster":                 "/serverless/regional/v1/clusters",
	"UpdateCluster":               fmt.Sprintf("/serverless/regional/v1/clusters/{%s}", idPathParameter),
	"CheckImportPermission":       "/serverless/regional/v1/import:checkPermission",
	"Precheck":                    "/serverless/regional/v1/import:precheck",
	"CheckCloudStoragePermission": "/serverless/regional/v1/clusters:checkCloudStoragePermission",
	"DMPrecheck":                  "/serverless/regional/v1/dm:precheck",
	"CreateVpcEndpoint":           "/serverless/regional/v1/dm:createVpcEndpoint",
	"DescribeVpcEndpoint":         "/serverless/regional/v1/dm:describeVpcEndpoint",
	"DeleteVpcEndpoint":           "/serverless/regional/v1/dm:deleteVpcEndpoint",
	"ListVpcEndpointZones":        "/serverless/regional/v1/dm:listVpcEndpointZones",
	"RemoveZoneFromVpcEndpoint":   "/serverless/regional/v1/dm:removeZoneFromVpcEndpoint",
	// --- PrivateLinkConnection (AWS & AliCloud) ---
	"CreateAWSVpcEndpoint":                      "/serverless/regional/v1/privateLinkConnection:createAWSVpcEndpoint",
	"DescribeAWSVpcEndpoint":                    "/serverless/regional/v1/privateLinkConnection:describeAWSVpcEndpoint",
	"DeleteAWSVpcEndpoint":                      "/serverless/regional/v1/privateLinkConnection:deleteAWSVpcEndpoint",
	"CreateAliCloudVpcEndpoint":                 "/serverless/regional/v1/privateLinkConnection:createAliCloudVpcEndpoint",
	"DescribeAliCloudVpcEndpoint":               "/serverless/regional/v1/privateLinkConnection:describeAliCloudVpcEndpoint",
	"DeleteAliCloudVpcEndpoint":                 "/serverless/regional/v1/privateLinkConnection:deleteAliCloudVpcEndpoint",
	"GetZoneIds":                                "/serverless/regional/v1/privateLinkConnection:getZoneIds",
	"ListAliCloudVpcEndpointZones":              "/serverless/regional/v1/privateLinkConnection:listAliCloudVpcEndpointZones",
	"RemoveAliCloudZoneFromVpcEndpoint":         "/serverless/regional/v1/privateLinkConnection:removeZoneFromAliCloudVpcEndpoint",
	"CreateAliCloudDNSRecord":                   "/serverless/regional/v1/privateLinkConnection:createAliCloudDNSRecord",
	"DeleteAliCloudDNSRecord":                   "/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSRecord",
	"CreateAWSRoute53Records":                   "/serverless/regional/v1/privateLinkConnection:createAWSRoute53Records",
	"DeleteAWSRoute53Records":                   "/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53Records",
	"GetAWSRoute53Change":                       "/serverless/regional/v1/privateLinkConnection:getAWSRoute53Change",
	"CreateAWSRoute53PrivateHostedZone":         "/serverless/regional/v1/privateLinkConnection:createAWSRoute53PrivateHostedZone",
	"DeleteAWSRoute53PrivateHostedZone":         "/serverless/regional/v1/privateLinkConnection:deleteAWSRoute53PrivateHostedZone",
	"CreateAliCloudDNSPrivateHostedZone":        "/serverless/regional/v1/privateLinkConnection:createAliCloudDNSPrivateHostedZone",
	"DeleteAliCloudDNSPrivateHostedZone":        "/serverless/regional/v1/privateLinkConnection:deleteAliCloudDNSPrivateHostedZone",
	"AttachVpcToAliCloudDNSPrivateHostedZone":   "/serverless/regional/v1/privateLinkConnection:attachVpcToAliCloudDNSPrivateHostedZone",
	"DetachVpcFromAliCloudDNSPrivateHostedZone": "/serverless/regional/v1/privateLinkConnection:detachVpcFromAliCloudDNSPrivateHostedZone",
	"CreateMSKVPCConnection":                    "/serverless/regional/v1/privateLinkConnection:createMSKVPCConnection",
	"DeleteMSKVPCConnection":                    "/serverless/regional/v1/privateLinkConnection:deleteMSKVPCConnection",
	"GetMSKVPCConnection":                       "/serverless/regional/v1/privateLinkConnection:getMSKVPCConnection",
}

type regionalServiceImpl struct {
	client *resty.Client
	proxy  *RegionalServiceProxy

	clusterRepo repository.ClusterRepo

	regionMap *sync.Map
}

type regionProbeTarget struct {
	address    string
	engineType globalcommonv1.Region_EngineType
}

func NewRegionServiceImpl(clusterRepo repository.ClusterRepo, proxy *RegionalServiceProxy) adapter.RegionalService {
	client := resty.New().
		SetRetryWaitTime(time.Duration(config.Global().RegionalServiceConfig.RetryWaitTimeoutInSec) * time.Second).
		SetRetryCount(config.Global().RegionalServiceConfig.RetryCount)

	client.SetHeader("Authorization", "Basic "+config.Global().RegionalServiceConfig.ClientAuthKey)
	svc := &regionalServiceImpl{
		client:      client,
		clusterRepo: clusterRepo,
		proxy:       proxy,
		regionMap:   &sync.Map{},
	}

	go svc.pingRegionalServer(context.Background())

	return svc
}

func (s *regionalServiceImpl) Describe(
	ctx context.Context,
	region *entity.Region,
) (*regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse, error) {
	ctx, cancel := createRequestTimeoutContext(ctx)
	defer cancel()

	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodGet,
		operationMap["DescribeRegion"],
		func(req *resty.Request) *resty.Request {
			req = req.SetBody(regionalserverlessv1.ServerlessRegionalServiceDescRegionRequest{})
			return req
		},
	)
	if err != nil {
		return &regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse{}, err
	}

	var out regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return &regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse{}, err
	}

	return &out, nil
}

func (s *regionalServiceImpl) CreateCluster(
	ctx context.Context,
	region *entity.Region,
	cluster *globalserverlessv1.ServerlessServiceCreateRequest,
) (*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	ctx, cancel := createRequestTimeoutContext(ctx)
	defer cancel()

	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["CreateCluster"],
		func(req *resty.Request) *resty.Request {
			req.SetPathParam(idPathParameter, cluster.Id)
			req.SetBody(adaptercvt.CreateReq2RegionSvcModel(cluster))
			return req
		},
	)
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.ServerlessRegionalServiceCreateClusterResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}

	return out.Cluster, err
}

func (s *regionalServiceImpl) DeleteCluster(
	ctx context.Context,
	region *entity.Region,
	clusterId string,
	tenantId, projectId uint64,
) error {
	ctx, cancel := createRequestTimeoutContext(ctx)
	defer cancel()

	_, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodDelete,
		operationMap["DeleteCluster"],
		func(req *resty.Request) *resty.Request {
			req.SetPathParam(idPathParameter, clusterId)
			req.SetQueryParam(tenantIdQueryParameter, fmt.Sprintf("%d", tenantId))
			req.SetQueryParam(projectIdQueryParameter, fmt.Sprintf("%d", projectId))
			return req
		},
	)
	if err != nil {
		s.proxy.Delete(ctx, clusterId)
	}

	return err
}

func (s *regionalServiceImpl) UpdateCluster(
	ctx context.Context,
	region *entity.Region,
	cluster *regionalserverlessv1.ServerlessRegionalServiceClusterInfo,
) (*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	ctx, cancel := createRequestTimeoutContext(ctx)
	defer cancel()

	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPatch,
		operationMap["UpdateCluster"],
		func(req *resty.Request) *resty.Request {
			req.SetPathParam(idPathParameter, cluster.ClusterId)

			req.SetBody(regionalserverlessv1.ServerlessRegionalServiceUpdateClusterRequest{
				ProjectId:      cluster.ProjectId,
				ClusterId:      cluster.ClusterId,
				Endpoints:      cluster.Endpoints,
				Annotations:    cluster.Annotations,
				AuditLogConfig: cluster.AuditLogConfig,
				AutoScaling:    cluster.AutoScaling,
			})
			return req
		},
	)
	if err != nil {
		return nil, err
	}

	s.proxy.Delete(ctx, cluster.ClusterId)

	var out regionalserverlessv1.ServerlessRegionalServiceUpdateClusterResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}

	return out.Cluster, nil
}

func (s *regionalServiceImpl) CheckImportPermission(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CheckImportPermissionRequest) (
	*regionalserverlessv1.CheckImportPermissionResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["CheckImportPermission"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		},
	)
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.CheckImportPermissionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) Precheck(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.PrecheckRequest) (
	*regionalserverlessv1.PrecheckResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["Precheck"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.PrecheckResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CheckCloudStoragePermission(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CheckCloudStoragePermissionRequest) (
	*regionalserverlessv1.CheckCloudStoragePermissionResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["CheckCloudStoragePermission"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		},
	)
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.CheckCloudStoragePermissionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DMPrecheck(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ServerlessDMRegionalServicePrecheckRequest) (
	*regionalserverlessv1.ServerlessDMRegionalServicePrecheckResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["DMPrecheck"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.ServerlessDMRegionalServicePrecheckResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateVpcEndpointRequest) (
	*regionalserverlessv1.CreateVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["CreateVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.CreateVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DescribeVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeVpcEndpointRequest) (
	*regionalserverlessv1.DescribeVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["DescribeVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.DescribeVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteVpcEndpointRequest) (
	*regionalserverlessv1.DeleteVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["DeleteVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.DeleteVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) ListVpcEndpointZones(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ListVpcEndpointZonesRequest,
) (*regionalserverlessv1.ListVpcEndpointZonesResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["ListVpcEndpointZones"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.ListVpcEndpointZonesResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) RemoveZoneFromVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.RemoveZoneFromVpcEndpointRequest,
) (*regionalserverlessv1.RemoveZoneFromVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost,
		operationMap["RemoveZoneFromVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.RemoveZoneFromVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) UpdateAuditLogConfig(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ServerlessRegionalServiceUpdateClusterRequest) (
	*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPatch,
		operationMap["UpdateCluster"],
		func(req *resty.Request) *resty.Request {
			req.SetPathParam(idPathParameter, r.ClusterId)
			req.SetBody(marshal)
			return req
		},
	)
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.ServerlessRegionalServiceUpdateClusterResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}

	return out.Cluster, nil
}

func (s *regionalServiceImpl) pingRegionalServer(ctx context.Context) {
	ticker := time.NewTicker(time.Minute)

	for range ticker.C {
		s.regionMap.Range(func(key, value any) bool {
			target, ok := value.(*regionProbeTarget)
			if !ok {
				return true
			}
			if isSys9EngineType(target.engineType) {
				return true
			}
			_, err := s.Describe(ctx, &entity.Region{
				Id:             key.(globalcommonv1.Region_Name),
				ServiceAddress: target.address,
				EngineType:     target.engineType,
			})
			if err != nil {
				tilog.Error(ctx, "describe region failed", zap.Any("region", key), zap.Any("address", target.address))
			}

			return true
		})
	}
}

func (s *regionalServiceImpl) CreateAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSVpcEndpointRequest,
) (*regionalserverlessv1.CreateAWSVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAWSVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAWSVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DescribeAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeAWSVpcEndpointRequest,
) (*regionalserverlessv1.DescribeAWSVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DescribeAWSVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DescribeAWSVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSVpcEndpointRequest,
) (*regionalserverlessv1.DeleteAWSVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAWSVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAWSVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.CreateAliCloudVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAliCloudVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAliCloudVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DescribeAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.DescribeAliCloudVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DescribeAliCloudVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DescribeAliCloudVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.DeleteAliCloudVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAliCloudVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAliCloudVpcEndpointResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) GetZoneIds(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetZoneIdsRequest,
) (*regionalserverlessv1.GetZoneIdsResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["GetZoneIds"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.GetZoneIdsResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) ListAliCloudVpcEndpointZones(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ListAliCloudVpcEndpointZonesRequest,
) (*regionalserverlessv1.ListAliCloudVpcEndpointZonesResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["ListAliCloudVpcEndpointZones"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.ListAliCloudVpcEndpointZonesResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) RemoveAliCloudZoneFromVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointRequest,
) (*regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["RemoveAliCloudZoneFromVpcEndpoint"],
		func(req *resty.Request) *resty.Request {
			req.SetBody(marshal)
			return req
		})
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointResponse

	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateAliCloudDNSRecord(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudDNSRecordRequest,
) (*regionalserverlessv1.CreateAliCloudDNSRecordResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAliCloudDNSRecord"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAliCloudDNSRecordResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAliCloudDNSRecord(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudDNSRecordRequest,
) (*regionalserverlessv1.DeleteAliCloudDNSRecordResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAliCloudDNSRecord"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAliCloudDNSRecordResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateAWSRoute53Records(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSRoute53RecordsRequest,
) (*regionalserverlessv1.CreateAWSRoute53RecordsResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAWSRoute53Records"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAWSRoute53RecordsResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAWSRoute53Records(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSRoute53RecordsRequest,
) (*regionalserverlessv1.DeleteAWSRoute53RecordsResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAWSRoute53Records"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAWSRoute53RecordsResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) GetAWSRoute53Change(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetAWSRoute53ChangeRequest,
) (*regionalserverlessv1.GetAWSRoute53ChangeResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["GetAWSRoute53Change"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.GetAWSRoute53ChangeResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateAWSRoute53PrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneRequest,
) (*regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAWSRoute53PrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAWSRoute53PrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneRequest,
) (*regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAWSRoute53PrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateAliCloudDNSPrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteAliCloudDNSPrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) AttachVpcToAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["AttachVpcToAliCloudDNSPrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DetachVpcFromAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DetachVpcFromAliCloudDNSPrivateHostedZone"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) CreateMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateMSKVPCConnectionRequest,
) (*regionalserverlessv1.CreateMSKVPCConnectionResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["CreateMSKVPCConnection"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.CreateMSKVPCConnectionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) DeleteMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteMSKVPCConnectionRequest,
) (*regionalserverlessv1.DeleteMSKVPCConnectionResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["DeleteMSKVPCConnection"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.DeleteMSKVPCConnectionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func (s *regionalServiceImpl) GetMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetMSKVPCConnectionRequest,
) (*regionalserverlessv1.GetMSKVPCConnectionResponse, error) {
	marshal, err := protojson.Marshal(r)
	if err != nil {
		return nil, err
	}
	resp, err := s.callRegion(ctx, region.Id, region.ServiceAddress,
		region.GetEngineType(),
		http.MethodPost, operationMap["GetMSKVPCConnection"],
		func(req *resty.Request) *resty.Request { return req.SetBody(marshal) })
	if err != nil {
		return nil, err
	}
	var out regionalserverlessv1.GetMSKVPCConnectionResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}
	if out.BaseResp != nil && out.BaseResp.ErrCode != 0 {
		return nil, bizerr.New(bizerr.ErrCode(out.BaseResp.ErrCode), "%s", out.BaseResp.ErrMsg)
	}
	return &out, nil
}

func filterState(
	clusters []*regionalserverlessv1.ServerlessRegionalServiceClusterInfo,
	states []regionalserverlessv1.ClusterState,
) []*regionalserverlessv1.ServerlessRegionalServiceClusterInfo {
	if len(states) == 0 {
		return clusters
	}

	stateMap := make(map[regionalserverlessv1.ClusterState]struct{})
	for _, state := range states {
		stateMap[state] = struct{}{}
	}

	out := make([]*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, 0)
	for _, cluster := range clusters {
		if _, ok := stateMap[cluster.State]; ok {
			out = append(out, cluster)
		}
	}

	return out
}

func (s *regionalServiceImpl) ListCluster(
	ctx context.Context,
	region *entity.Region,
	req *globalserverlessv1.ServerlessServiceListRequest,
) ([]*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	if req.Filter != nil && len(req.Filter.ClusterIds) > 0 && !req.Filter.GetRefreshCache() {
		clusters, ok := s.proxy.GetReadyClusterByIds(ctx, req.Filter.ClusterIds)
		if ok {
			return filterState(clusters, req.Filter.States), nil
		}
	}

	if req.Filter != nil && config.Global().RegionalServiceConfig.AllowRequestMaxClusterIdCount > 0 {
		if len(req.Filter.ClusterIds) > config.Global().RegionalServiceConfig.AllowRequestMaxClusterIdCount {
			return nil, fmt.Errorf(
				"the number of Cluster Ids exceeds the upper limit: %d",
				config.Global().RegionalServiceConfig.AllowRequestMaxClusterIdCount,
			)
		}
	}
	resp, err := s.callRegion(
		ctx,
		region.Id,
		region.ServiceAddress,
		region.GetEngineType(),
		http.MethodGet,
		operationMap["ListCluster"],
		func(request *resty.Request) *resty.Request {
			queryParams, err := protobufStructToMap(adaptercvt.ListReq2RegionSvcListReq(req))
			if err != nil {
				return nil
			}

			for key, value := range queryParams {
				switch val := value.(type) {
				case []any:
					request.SetQueryParamsFromValues(convertArrayFieldValueToValues(key, val))
				default:
					request.SetQueryParam(key, fmt.Sprintf("%v", value))
				}
			}

			return request
		},
	)
	if err != nil {
		return nil, err
	}

	var out regionalserverlessv1.ServerlessRegionalServiceListClustersResponse
	if err := unmarshalOptions.Unmarshal(resp.Body(), &out); err != nil {
		return nil, err
	}

	s.proxy.ReadyClusterBatchSet(ctx, out.Clusters)
	return out.Clusters, nil
}

type OperationFunc func(region *entity.Region) error

func (s *regionalServiceImpl) callRegion(
	ctx context.Context,
	region globalcommonv1.Region_Name,
	address string,
	engineType globalcommonv1.Region_EngineType,
	method, apiPath string,
	setParam func(req *resty.Request) *resty.Request,
) (*resty.Response, error) {
	resp, err := httputil.DoRequest(ctx, s.client, method, address, apiPath, func(req *resty.Request) {
		req.ForceContentType("application/json")
		setParam(req)
		req.SetHeader("Authorization", "Basic "+config.Global().RegionalServiceConfig.ClientAuthKey)
	})
	if err != nil {
		return nil, fmt.Errorf("http request failed: %w", err)
	}

	s.regionMap.Store(region, &regionProbeTarget{
		address:    address,
		engineType: engineType,
	})

	if (resp.StatusCode() < http.StatusOK || resp.StatusCode() >= http.StatusMultipleChoices) &&
		// 409 means the resource already exists
		resp.StatusCode() != http.StatusConflict {
		return resp, errors.New("call region service failed")
	}

	return resp, nil
}

func isSys9EngineType(engineType globalcommonv1.Region_EngineType) bool {
	return engineType == globalcommonv1.Region_POSTGRESQL_COMPATIBLE
}

func protobufStructToMap(s proto.Message) (map[string]any, error) {
	b, err := protojson.Marshal(s)
	if err != nil {
		return nil, err
	}
	m := make(map[string]any)
	err = json.Unmarshal(b, &m)
	if err != nil {
		return nil, err
	}
	return m, nil
}

func convertArrayFieldValueToValues(key string, values []any) url.Values {
	result := make([]string, 0)
	for _, value := range values {
		strValue := fmt.Sprintf("%v", value)
		result = append(result, strValue)
	}
	return url.Values{
		key: result,
	}
}

// createRequestTimeoutContext creates a context with timeout based on the global config
// use context to set timeout instead of using resty's timeout, see https://github.com/go-resty/resty/discussions/763
func createRequestTimeoutContext(ctx context.Context) (context.Context, context.CancelFunc) {
	return context.WithTimeout(
		ctx,
		time.Duration(config.Global().RegionalServiceConfig.RequestTimeoutInSec)*time.Second,
	)
}

type fakeRegionService struct {
	sync.Once

	regionSvc    adapter.RegionalService
	dbProvider   db.Provider
	clusterRepo  repository.ClusterRepo
	providerRepo repository.CloudProviderRepo
	proxy        *RegionalServiceProxy
}

func NewFakeRegionService(
	dbProvider db.Provider,
	clusterRepo repository.ClusterRepo,
	providerRepo repository.CloudProviderRepo,
	proxy *RegionalServiceProxy,
) adapter.RegionalService {
	return &fakeRegionService{
		proxy:        proxy,
		dbProvider:   dbProvider,
		clusterRepo:  clusterRepo,
		providerRepo: providerRepo,
		regionSvc:    NewRegionServiceImpl(clusterRepo, proxy),
	}
}

func (s *fakeRegionService) Describe(
	ctx context.Context,
	region *entity.Region,
) (*regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.Describe(ctx, region)
	}

	providerName, err := s.getProviderName(ctx)
	if err != nil {
		return nil, err
	}

	return &regionalserverlessv1.ServerlessRegionalServiceDescRegionResponse{
		Name:          "us-west-2",
		DisplayName:   "us-west-2",
		CloudProvider: svccvt.Name2CloudProviderEnum(providerName.String()),
	}, nil
}

func (s *fakeRegionService) getProviderName(ctx context.Context) (globalcommonv1.CloudProvider_Name, error) {
	providers, err := s.providerRepo.LoadAll(ctx)
	if err != nil {
		return globalcommonv1.CloudProvider_NAME_UNSPECIFIED, err
	}
	if len(providers) == 0 {
		return globalcommonv1.CloudProvider_NAME_UNSPECIFIED, errors.New("empty cloud provider")
	}

	for _, p := range providers {
		return p.Id, nil
	}

	return globalcommonv1.CloudProvider_NAME_UNSPECIFIED, errors.New("empty cloud provider")
}

func (s *fakeRegionService) CreateCluster(
	ctx context.Context,
	region *entity.Region,
	cluster *globalserverlessv1.ServerlessServiceCreateRequest,
) (*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateCluster(ctx, region, cluster)
	}

	if cluster == nil {
		return nil, errors.New("empty cluster")
	}
	if cluster.ProjectId == 0 {
		return nil, errors.New("empty project id")
	}
	if cluster.TenantId == 0 {
		return nil, errors.New("empty tenant id")
	}
	if region.Id.String() != cluster.Region {
		return nil, errors.New("region should be equal")
	}

	return &regionalserverlessv1.ServerlessRegionalServiceClusterInfo{
		ClusterId: cluster.Id,
		Region: &regionalserverlessv1.Region{
			Name:          region.Id.String(),
			DisplayName:   region.DisplayName,
			CloudProvider: svccvt.Name2CloudProviderEnum(region.CloudProviderId.String()),
		},
	}, nil
}

func (s *fakeRegionService) UpdateCluster(
	ctx context.Context,
	region *entity.Region,
	cluster *regionalserverlessv1.ServerlessRegionalServiceClusterInfo,
) (*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.UpdateCluster(ctx, region, cluster)
	}
	if cluster == nil {
		return nil, errors.New("empty cluster")
	}
	if cluster.Endpoints == nil || (cluster.Endpoints.Public == nil && cluster.Endpoints.Private == nil) {
		return nil, errors.New("endpoints are empty")
	}
	s.proxy.Delete(ctx, cluster.ClusterId)
	return cluster, nil
}

func (s *fakeRegionService) DeleteCluster(
	ctx context.Context,
	region *entity.Region,
	clusterId string,
	tenantId, projectId uint64,
) error {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteCluster(ctx, region, clusterId, tenantId, projectId)
	}

	if clusterId == "" {
		return errors.New("empty cluster id")
	}
	if region == nil || region.Id == 0 {
		return errors.New("empty region")
	}

	_, err := strconv.ParseUint(clusterId, 10, 64)
	if err != nil {
		return err
	}
	s.proxy.Delete(ctx, clusterId)
	return nil
}

func (s *fakeRegionService) ListCluster(
	ctx context.Context,
	region *entity.Region,
	req *globalserverlessv1.ServerlessServiceListRequest,
) ([]*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	if req.Filter != nil && len(req.Filter.ClusterIds) > 0 {
		clusters, ok := s.proxy.GetReadyClusterByIds(ctx, req.Filter.ClusterIds)
		if ok {
			return filterState(clusters, req.Filter.States), nil
		}
	}

	if region.ServiceAddress != "" {
		return s.regionSvc.ListCluster(ctx, region, req)
	}
	var deleted bool
	if req.Filter != nil && req.Filter.Deleted != nil {
		deleted = *req.Filter.Deleted
	}
	clusters, err := s.clusterRepo.Query(ctx, &repository.ClusterQueryParameter{
		ClusterIds: req.Filter.ClusterIds,
		Deleted:    deleted,
	})
	if err != nil {
		return nil, err
	}

	out := make([]*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, len(clusters))
	for index, cluster := range clusters {
		out[index] = &regionalserverlessv1.ServerlessRegionalServiceClusterInfo{
			ClusterId: cluster.ClusterId,
			Version:   "7.0.0",
			State:     regionalserverlessv1.ClusterState_CLUSTER_STATE_READY,
			CreatedTs: cluster.CreatedAt.Unix(),
			DeleteTs:  cluster.DeletedAt.Unix(),
			UpdatedTs: cluster.UpdatedAt.Unix(),
			Region: &regionalserverlessv1.Region{
				Name:          cluster.Region.Id.String(),
				DisplayName:   cluster.Region.DisplayName,
				CloudProvider: regionalserverlessv1.CloudProvider_CLOUD_PROVIDER_AWS,
			},
			UserPrefix: "prefix-test",
			Endpoints: &regionalserverlessv1.Endpoints{
				Private: &regionalserverlessv1.PrivateEndpoint{
					Host: "tidb-vpce-xxx",
					Port: 4000,
				},
				Public: &regionalserverlessv1.PublicEndpoint{
					Host: "tidb-gateway-xxx",
					Port: 4000,
				},
			},
			ProxyEndpoint: "endpoint.com",
			TenantId:      1,
		}
	}

	s.proxy.ReadyClusterBatchSet(ctx, out)
	return out, nil
}

func (s *fakeRegionService) CheckImportPermission(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CheckImportPermissionRequest) (
	*regionalserverlessv1.CheckImportPermissionResponse, error) {
	return &regionalserverlessv1.CheckImportPermissionResponse{}, nil
}

func (s *fakeRegionService) Precheck(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.PrecheckRequest) (
	*regionalserverlessv1.PrecheckResponse, error) {
	return &regionalserverlessv1.PrecheckResponse{}, nil
}

func (s *fakeRegionService) CheckCloudStoragePermission(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CheckCloudStoragePermissionRequest) (
	*regionalserverlessv1.CheckCloudStoragePermissionResponse, error) {
	return &regionalserverlessv1.CheckCloudStoragePermissionResponse{}, nil
}

func (s *fakeRegionService) UpdateAuditLogConfig(
	ctx context.Context,
	region *entity.Region,
	regionalCluster *regionalserverlessv1.ServerlessRegionalServiceUpdateClusterRequest,
) (*regionalserverlessv1.ServerlessRegionalServiceClusterInfo, error) {
	return &regionalserverlessv1.ServerlessRegionalServiceClusterInfo{}, nil
}

func (s *fakeRegionService) DMPrecheck(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ServerlessDMRegionalServicePrecheckRequest) (
	*regionalserverlessv1.ServerlessDMRegionalServicePrecheckResponse, error) {
	return &regionalserverlessv1.ServerlessDMRegionalServicePrecheckResponse{}, nil
}

func (s *fakeRegionService) CreateVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateVpcEndpointRequest) (
	*regionalserverlessv1.CreateVpcEndpointResponse, error) {
	return &regionalserverlessv1.CreateVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DescribeVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeVpcEndpointRequest) (
	*regionalserverlessv1.DescribeVpcEndpointResponse, error) {
	return &regionalserverlessv1.DescribeVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DeleteVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteVpcEndpointRequest) (
	*regionalserverlessv1.DeleteVpcEndpointResponse, error) {
	return &regionalserverlessv1.DeleteVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) ListVpcEndpointZones(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ListVpcEndpointZonesRequest,
) (*regionalserverlessv1.ListVpcEndpointZonesResponse, error) {
	return &regionalserverlessv1.ListVpcEndpointZonesResponse{}, nil
}

func (s *fakeRegionService) RemoveZoneFromVpcEndpoint(ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.RemoveZoneFromVpcEndpointRequest,
) (*regionalserverlessv1.RemoveZoneFromVpcEndpointResponse, error) {
	return &regionalserverlessv1.RemoveZoneFromVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) CreateAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSVpcEndpointRequest,
) (*regionalserverlessv1.CreateAWSVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAWSVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAWSVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DescribeAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeAWSVpcEndpointRequest,
) (*regionalserverlessv1.DescribeAWSVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DescribeAWSVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.DescribeAWSVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DeleteAWSVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSVpcEndpointRequest,
) (*regionalserverlessv1.DeleteAWSVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAWSVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAWSVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) CreateAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.CreateAliCloudVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAliCloudVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAliCloudVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DescribeAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DescribeAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.DescribeAliCloudVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DescribeAliCloudVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.DescribeAliCloudVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) DeleteAliCloudVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudVpcEndpointRequest,
) (*regionalserverlessv1.DeleteAliCloudVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAliCloudVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAliCloudVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) GetZoneIds(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetZoneIdsRequest,
) (*regionalserverlessv1.GetZoneIdsResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.GetZoneIds(ctx, region, r)
	}
	return &regionalserverlessv1.GetZoneIdsResponse{}, nil
}

func (s *fakeRegionService) ListAliCloudVpcEndpointZones(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.ListAliCloudVpcEndpointZonesRequest,
) (*regionalserverlessv1.ListAliCloudVpcEndpointZonesResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.ListAliCloudVpcEndpointZones(ctx, region, r)
	}
	return &regionalserverlessv1.ListAliCloudVpcEndpointZonesResponse{}, nil
}

func (s *fakeRegionService) RemoveAliCloudZoneFromVpcEndpoint(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointRequest,
) (*regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.RemoveAliCloudZoneFromVpcEndpoint(ctx, region, r)
	}
	return &regionalserverlessv1.RemoveAliCloudZoneFromVpcEndpointResponse{}, nil
}

func (s *fakeRegionService) CreateAliCloudDNSRecord(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudDNSRecordRequest,
) (*regionalserverlessv1.CreateAliCloudDNSRecordResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAliCloudDNSRecord(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAliCloudDNSRecordResponse{}, nil
}

func (s *fakeRegionService) DeleteAliCloudDNSRecord(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudDNSRecordRequest,
) (*regionalserverlessv1.DeleteAliCloudDNSRecordResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAliCloudDNSRecord(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAliCloudDNSRecordResponse{}, nil
}

func (s *fakeRegionService) CreateAWSRoute53Records(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSRoute53RecordsRequest,
) (*regionalserverlessv1.CreateAWSRoute53RecordsResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAWSRoute53Records(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAWSRoute53RecordsResponse{}, nil
}

func (s *fakeRegionService) DeleteAWSRoute53Records(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSRoute53RecordsRequest,
) (*regionalserverlessv1.DeleteAWSRoute53RecordsResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAWSRoute53Records(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAWSRoute53RecordsResponse{}, nil
}

func (s *fakeRegionService) GetAWSRoute53Change(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetAWSRoute53ChangeRequest,
) (*regionalserverlessv1.GetAWSRoute53ChangeResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.GetAWSRoute53Change(ctx, region, r)
	}
	return &regionalserverlessv1.GetAWSRoute53ChangeResponse{}, nil
}

func (s *fakeRegionService) CreateAWSRoute53PrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneRequest,
) (*regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAWSRoute53PrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAWSRoute53PrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) DeleteAWSRoute53PrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneRequest,
) (*regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAWSRoute53PrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAWSRoute53PrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) CreateAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateAliCloudDNSPrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.CreateAliCloudDNSPrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) DeleteAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteAliCloudDNSPrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteAliCloudDNSPrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) AttachVpcToAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.AttachVpcToAliCloudDNSPrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.AttachVpcToAliCloudDNSPrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) DetachVpcFromAliCloudDNSPrivateHostedZone(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneRequest,
) (*regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DetachVpcFromAliCloudDNSPrivateHostedZone(ctx, region, r)
	}
	return &regionalserverlessv1.DetachVpcFromAliCloudDNSPrivateHostedZoneResponse{}, nil
}

func (s *fakeRegionService) CreateMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.CreateMSKVPCConnectionRequest,
) (*regionalserverlessv1.CreateMSKVPCConnectionResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.CreateMSKVPCConnection(ctx, region, r)
	}
	return &regionalserverlessv1.CreateMSKVPCConnectionResponse{}, nil
}

func (s *fakeRegionService) DeleteMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.DeleteMSKVPCConnectionRequest,
) (*regionalserverlessv1.DeleteMSKVPCConnectionResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.DeleteMSKVPCConnection(ctx, region, r)
	}
	return &regionalserverlessv1.DeleteMSKVPCConnectionResponse{}, nil
}

func (s *fakeRegionService) GetMSKVPCConnection(
	ctx context.Context,
	region *entity.Region,
	r *regionalserverlessv1.GetMSKVPCConnectionRequest,
) (*regionalserverlessv1.GetMSKVPCConnectionResponse, error) {
	if region.ServiceAddress != "" {
		return s.regionSvc.GetMSKVPCConnection(ctx, region, r)
	}
	return &regionalserverlessv1.GetMSKVPCConnectionResponse{}, nil
}