// Deprecated: Code in this directory should only be invoked from core-portal.
//	Once the consolidation is complete, we can delete this directory and offline the core-portal process.

package core

import (
	"context"
	"strconv"

	coreapi "github.com/tidbcloud/core-svc/idl/pbgen/proto/core"
	"go.buf.build/protocolbuffers/go/linuxgit/tidbcloud/base"

	clusterapp "github.com/tidbcloud/tidb-management-service/dedicated-global-service/app/core/cluster"
	cmekapp "github.com/tidbcloud/tidb-management-service/dedicated-global-service/app/core/cmek"
	networkapp "github.com/tidbcloud/tidb-management-service/dedicated-global-service/app/core/network"
	regionapp "github.com/tidbcloud/tidb-management-service/dedicated-global-service/app/core/region"
	"github.com/tidbcloud/tidb-management-service/utilities/grpc/metadata"
)

type Controller struct {
	coreapi.UnimplementedCoreServiceServer

	createPrivateLinkServiceSvc         *networkapp.CreatePrivateLinkServiceSvc
	getPrivateLinkServiceSvc            *networkapp.GetPrivateLinkServiceSvc
	deletePrivateLinkServiceSvc         *networkapp.DeletePrivateLinkServiceSvc
	createClusterConnSvc                *clusterapp.CreateClusterConnSvc
	updateClusterTrafficFilterSvc       *clusterapp.UpdateClusterTrafficFilterSvc
	createPrivateLinkEndpointSvc        *networkapp.CreatePrivateLinkEndpointSvc
	deletePrivateLinkEndpointSvc        *networkapp.DeletePrivateLinkEndpointSvc
	listPrivateLinkEndpointsSvc         *networkapp.ListPrivateLinkEndpointsSvc
	createWorkPoolSvc                   *clusterapp.CreateWorkPoolSvc
	updateWorkPoolSvc                   *clusterapp.UpdateWorkPoolSvc
	deleteWorkPoolSvc                   *clusterapp.DeleteWorkPoolSvc
	listWorkPoolPrivateLinkEndpointsSvc *networkapp.ListWorkPoolPrivateLinkEndpointsSvc
	queryWorkPoolsSvc                   *networkapp.QueryWorkPoolsSvc
	createVpcPeeringSvc                 *networkapp.CreateVpcPeeringSvc
	deleteVpcPeeringSvc                 *networkapp.DeleteVpcPeeringSvc
	listVpcPeeringSvc                   *networkapp.ListVpcPeeringSvc
	createClusterSnapshotSvc            *clusterapp.CreateClusterSnapshotSvc
	listClusterSnapshotsSvc             *clusterapp.ListClusterSnapshotsSvc
	queryTenantQuotaSvc                 *clusterapp.QueryTenantQuotaSvc
	updateTenantQuotaSvc                *clusterapp.UpdateTenantQuotaSvc
	listCloudProvidersSvc               *regionapp.ListCloudProvidersSvc
	listCloudRegionsSvc                 *regionapp.ListCloudRegionsSvc
	listNodeProfiles4TenantSvc          *regionapp.ListNodeProfiles4TenantSvc
	changeClusterPasswdSvc              *clusterapp.ChangeClusterPasswdSvc
	createCidrSvc                       *networkapp.CreateCidrSvc
	updateCidrSvc                       *networkapp.UpdateCidrSvc
	deleteCidrSvc                       *networkapp.DeleteCidrSvc
	queryCidrsSvc                       *networkapp.QueryCidrsSvc
	getDefaultCidrSvc                   *networkapp.GetDefaultCidrSvc
	getAwsAccountSvc                    *cmekapp.GetCmekAccountSvc
	createAwsCmekSvc                    *cmekapp.CreateCmekSvc
	listAwsCmekSvc                      *cmekapp.ListCmekSvc
	getClusterCACertificateSvc          *clusterapp.GetClusterCACertificateSvc
}

func NewCoreServer(
	createPrivateLinkServiceSvc *networkapp.CreatePrivateLinkServiceSvc,
	getPrivateLinkServiceSvc *networkapp.GetPrivateLinkServiceSvc,
	deletePrivateLinkServiceSvc *networkapp.DeletePrivateLinkServiceSvc,
	createClusterConnSvc *clusterapp.CreateClusterConnSvc,
	updateClusterTrafficFilterSvc *clusterapp.UpdateClusterTrafficFilterSvc,
	createPrivateLinkEndpointSvc *networkapp.CreatePrivateLinkEndpointSvc,
	deletePrivateLinkEndpointSvc *networkapp.DeletePrivateLinkEndpointSvc,
	listPrivateLinkEndpointsSvc *networkapp.ListPrivateLinkEndpointsSvc,
	createWorkPoolSvc *clusterapp.CreateWorkPoolSvc,
	updateWorkPoolSvc *clusterapp.UpdateWorkPoolSvc,
	deleteWorkPoolSvc *clusterapp.DeleteWorkPoolSvc,
	listWorkPoolPrivateLinkEndpointsSvc *networkapp.ListWorkPoolPrivateLinkEndpointsSvc,
	queryWorkPoolsSvc *networkapp.QueryWorkPoolsSvc,
	createVpcPeeringSvc *networkapp.CreateVpcPeeringSvc,
	deleteVpcPeeringSvc *networkapp.DeleteVpcPeeringSvc,
	listVpcPeeringSvc *networkapp.ListVpcPeeringSvc,
	createClusterSnapshotSvc *clusterapp.CreateClusterSnapshotSvc,
	listClusterSnapshotsSvc *clusterapp.ListClusterSnapshotsSvc,
	queryTenantQuotaSvc *clusterapp.QueryTenantQuotaSvc,
	updateTenantQuotaSvc *clusterapp.UpdateTenantQuotaSvc,
	listCloudProvidersSvc *regionapp.ListCloudProvidersSvc,
	listCloudRegionsSvc *regionapp.ListCloudRegionsSvc,
	listNodeProfiles4TenantSvc *regionapp.ListNodeProfiles4TenantSvc,
	changeClusterPasswdSvc *clusterapp.ChangeClusterPasswdSvc,
	createCidrSvc *networkapp.CreateCidrSvc,
	updateCidrSvc *networkapp.UpdateCidrSvc,
	deleteCidrSvc *networkapp.DeleteCidrSvc,
	queryCidrsSvc *networkapp.QueryCidrsSvc,
	getDefaultCidrSvc *networkapp.GetDefaultCidrSvc,
	getAwsAccountSvc *cmekapp.GetCmekAccountSvc,
	createAwsCmekSvc *cmekapp.CreateCmekSvc,
	listAwsCmekSvc *cmekapp.ListCmekSvc,
	getClusterCACertificateSvc *clusterapp.GetClusterCACertificateSvc,
) coreapi.CoreServiceServer {
	return &Controller{
		createPrivateLinkServiceSvc:         createPrivateLinkServiceSvc,
		getPrivateLinkServiceSvc:            getPrivateLinkServiceSvc,
		deletePrivateLinkServiceSvc:         deletePrivateLinkServiceSvc,
		createClusterConnSvc:                createClusterConnSvc,
		updateClusterTrafficFilterSvc:       updateClusterTrafficFilterSvc,
		createPrivateLinkEndpointSvc:        createPrivateLinkEndpointSvc,
		deletePrivateLinkEndpointSvc:        deletePrivateLinkEndpointSvc,
		listPrivateLinkEndpointsSvc:         listPrivateLinkEndpointsSvc,
		createWorkPoolSvc:                   createWorkPoolSvc,
		updateWorkPoolSvc:                   updateWorkPoolSvc,
		deleteWorkPoolSvc:                   deleteWorkPoolSvc,
		listWorkPoolPrivateLinkEndpointsSvc: listWorkPoolPrivateLinkEndpointsSvc,
		queryWorkPoolsSvc:                   queryWorkPoolsSvc,
		createVpcPeeringSvc:                 createVpcPeeringSvc,
		deleteVpcPeeringSvc:                 deleteVpcPeeringSvc,
		listVpcPeeringSvc:                   listVpcPeeringSvc,
		createClusterSnapshotSvc:            createClusterSnapshotSvc,
		listClusterSnapshotsSvc:             listClusterSnapshotsSvc,
		queryTenantQuotaSvc:                 queryTenantQuotaSvc,
		updateTenantQuotaSvc:                updateTenantQuotaSvc,
		listCloudProvidersSvc:               listCloudProvidersSvc,
		listCloudRegionsSvc:                 listCloudRegionsSvc,
		listNodeProfiles4TenantSvc:          listNodeProfiles4TenantSvc,
		changeClusterPasswdSvc:              changeClusterPasswdSvc,
		createCidrSvc:                       createCidrSvc,
		updateCidrSvc:                       updateCidrSvc,
		deleteCidrSvc:                       deleteCidrSvc,
		queryCidrsSvc:                       queryCidrsSvc,
		getDefaultCidrSvc:                   getDefaultCidrSvc,
		getAwsAccountSvc:                    getAwsAccountSvc,
		createAwsCmekSvc:                    createAwsCmekSvc,
		listAwsCmekSvc:                      listAwsCmekSvc,
		getClusterCACertificateSvc:          getClusterCACertificateSvc,
	}
}

func (c *Controller) CreatePrivateLinkService(
	ctx context.Context,
	req *coreapi.CreatePrivateLinkServiceReq,
) (*coreapi.CreatePrivateLinkServiceResp, error) {
	resp := &coreapi.CreatePrivateLinkServiceResp{
		PrivatelinkService: nil,
		BaseResp:           &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.OrgId,
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
		ClusterID:        req.ClusterId,
	})

	privateLinkService, err := c.createPrivateLinkServiceSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.PrivatelinkService = privateLinkService
	return resp, nil
}

func (c *Controller) GetPrivateLinkService(
	ctx context.Context,
	req *coreapi.GetPrivateLinkServiceReq,
) (*coreapi.GetPrivateLinkServiceResp, error) {
	resp := &coreapi.GetPrivateLinkServiceResp{
		PrivatelinkService: nil,
		BaseResp:           &base.BaseResp{},
	}

	privateLinkService, err := c.getPrivateLinkServiceSvc.Get(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.PrivatelinkService = privateLinkService
	return resp, nil
}

func (c *Controller) DeletePrivateLinkService(
	ctx context.Context,
	req *coreapi.DeletePrivateLinkServiceReq,
) (*coreapi.DeletePrivateLinkServiceResp, error) {
	resp := &coreapi.DeletePrivateLinkServiceResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.OrgId,
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
		ClusterID:        req.ClusterId,
	})

	err := c.deletePrivateLinkServiceSvc.Delete(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) CreateClusterConn(
	ctx context.Context,
	req *coreapi.CreateClusterConnReq,
) (*coreapi.CreateClusterConnResp, error) {
	resp := &coreapi.CreateClusterConnResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID: req.ClusterId,
	})

	err := c.createClusterConnSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) UpdateClusterTrafficFilter(
	ctx context.Context,
	req *coreapi.UpdateClusterTrafficFilterReq,
) (*coreapi.UpdateClusterTrafficFilterResp, error) {
	resp := &coreapi.UpdateClusterTrafficFilterResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID: req.ClusterId,
	})

	err := c.updateClusterTrafficFilterSvc.Update(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) CreatePrivateLinkEndpoint(
	ctx context.Context,
	req *coreapi.CreatePrivateLinkEndpointReq,
) (*coreapi.CreatePrivateLinkEndpointResp, error) {
	resp := &coreapi.CreatePrivateLinkEndpointResp{
		PrivatelinkEndpoint: nil,
		BaseResp:            &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.OrgId,
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
		ClusterID:        req.ClusterId,
		ResourceID:       strconv.FormatUint(req.GetAccessPointId(), 10),
	})

	privateLinkEndpoint, err := c.createPrivateLinkEndpointSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.PrivatelinkEndpoint = privateLinkEndpoint
	return resp, nil
}

func (c *Controller) DeletePrivateLinkEndpoint(
	ctx context.Context,
	req *coreapi.DeletePrivateLinkEndpointReq,
) (*coreapi.DeletePrivateLinkEndpointResp, error) {
	resp := &coreapi.DeletePrivateLinkEndpointResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.OrgId,
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
		ClusterID:        req.ClusterId,
		ResourceID:       strconv.FormatUint(req.GetAccessPointId(), 10),
	})

	err := c.deletePrivateLinkEndpointSvc.Delete(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) ListPrivateLinkEndpoints(
	ctx context.Context,
	req *coreapi.ListPrivateLinkEndpointsReq,
) (*coreapi.ListPrivateLinkEndpointsResp, error) {
	resp := &coreapi.ListPrivateLinkEndpointsResp{
		Endpoints: nil,
		BaseResp:  &base.BaseResp{},
	}

	endpoints, err := c.listPrivateLinkEndpointsSvc.List(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Endpoints = endpoints
	return resp, nil
}

func (c *Controller) CreateAccessPoint(
	ctx context.Context,
	req *coreapi.CreateAccessPointReq,
) (*coreapi.CreateAccessPointResp, error) {
	resp := &coreapi.CreateAccessPointResp{
		Id:       0,
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID: req.ClusterId,
	})

	id, err := c.createWorkPoolSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Id = id
	return resp, nil
}

func (c *Controller) UpdateAccessPoint(
	ctx context.Context,
	req *coreapi.UpdateAccessPointReq,
) (*coreapi.UpdateAccessPointResp, error) {
	resp := &coreapi.UpdateAccessPointResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID:  req.ClusterId,
		ResourceID: strconv.FormatUint(req.Id, 10),
	})

	err := c.updateWorkPoolSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) DeleteAccessPoint(
	ctx context.Context,
	req *coreapi.DeleteAccessPointReq,
) (*coreapi.DeleteAccessPointResp, error) {
	resp := &coreapi.DeleteAccessPointResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID:  req.ClusterId,
		ResourceID: strconv.FormatUint(req.Id, 10),
	})

	err := c.deleteWorkPoolSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) ListAccessPointPrivateLinkEndpoints(
	ctx context.Context,
	req *coreapi.ListAccessPointPrivateLinkEndpointsReq,
) (*coreapi.ListAccessPointPrivateLinkEndpointsResp, error) {
	resp := &coreapi.ListAccessPointPrivateLinkEndpointsResp{
		Endpoints: nil,
		BaseResp:  &base.BaseResp{},
	}

	endpoints, err := c.listWorkPoolPrivateLinkEndpointsSvc.List(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Endpoints = endpoints
	return resp, nil
}

func (c *Controller) QueryAccessPoints(
	ctx context.Context,
	req *coreapi.QueryAccessPointsReq,
) (*coreapi.QueryAccessPointsResp, error) {
	resp := &coreapi.QueryAccessPointsResp{
		AccessPoints: nil,
		BaseResp:     &base.BaseResp{},
	}

	accessPoints, err := c.queryWorkPoolsSvc.Query(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.AccessPoints = accessPoints
	return resp, nil
}

func (c *Controller) CreateNetworkPeer(
	ctx context.Context,
	req *coreapi.CreateNetworkPeerReq,
) (*coreapi.CreateNetworkPeerResp, error) {
	resp := &coreapi.CreateNetworkPeerResp{
		PeeringId: 0,
		BaseResp:  &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.GetPeering().GetTenantId(),
		DefaultProjectID: req.GetPeering().GetProjectId(),
		ValidProjectList: []uint64{req.GetPeering().GetProjectId()},
	})

	peeringId, err := c.createVpcPeeringSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.PeeringId = peeringId
	return resp, nil
}

func (c *Controller) DeleteNetworkPeer(
	ctx context.Context,
	req *coreapi.DeleteNetworkPeerReq,
) (*coreapi.DeleteNetworkPeerResp, error) {
	resp := &coreapi.DeleteNetworkPeerResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ResourceID: strconv.FormatUint(req.GetPeeringId(), 10),
	})

	err := c.deleteVpcPeeringSvc.Delete(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) ListNetworkPeer(
	ctx context.Context,
	req *coreapi.ListNetworkPeerReq,
) (*coreapi.ListNetworkPeerResp, error) {
	resp := &coreapi.ListNetworkPeerResp{
		PeeringList: nil,
		BaseResp:    &base.BaseResp{},
	}

	peeringList, err := c.listVpcPeeringSvc.List(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.PeeringList = peeringList
	return resp, nil
}

func (c *Controller) CreateClusterSnapshot(
	ctx context.Context,
	req *coreapi.CreateClusterSnapshotReq,
) (*coreapi.CreateClusterSnapshotResp, error) {
	resp := &coreapi.CreateClusterSnapshotResp{
		SnapshotId: 0,
		BaseResp:   &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID: req.ClusterId,
	})

	snapshotId, err := c.createClusterSnapshotSvc.Execute(ctx, req.ClusterId)
	if err != nil {
		return resp, err
	}

	resp.SnapshotId = snapshotId
	return resp, nil
}

func (c *Controller) ListClusterSnapshots(
	ctx context.Context,
	req *coreapi.ListClusterSnapshotsReq,
) (*coreapi.ListClusterSnapshotsResp, error) {
	resp := &coreapi.ListClusterSnapshotsResp{
		Snapshots: nil,
		BaseResp:  &base.BaseResp{},
	}

	snapshots, err := c.listClusterSnapshotsSvc.List(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Snapshots = snapshots
	return resp, nil
}

func (c *Controller) ListTenantQuota(
	ctx context.Context,
	req *coreapi.ListTenantQuotaReq,
) (*coreapi.ListTenantQuotaResp, error) {
	resp := &coreapi.ListTenantQuotaResp{
		TenantQuotas: nil,
		BaseResp:     &base.BaseResp{},
	}

	quotas, err := c.queryTenantQuotaSvc.Query(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.TenantQuotas = quotas
	return resp, nil
}

func (c *Controller) UpdateTenantQuota(
	ctx context.Context,
	req *coreapi.UpdateTenantQuotaReq,
) (*coreapi.UpdateTenantQuotaResp, error) {
	resp := &coreapi.UpdateTenantQuotaResp{
		TenantQuota: nil,
		BaseResp:    &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID: req.GetTenantId(),
	})

	err := c.updateTenantQuotaSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) ListCloudProviders(
	ctx context.Context,
	req *coreapi.ListCloudProvidersReq,
) (*coreapi.ListCloudProvidersResp, error) {
	resp := &coreapi.ListCloudProvidersResp{
		Name2CloudProvider: nil,
		BaseResp:           &base.BaseResp{},
	}

	providers, err := c.listCloudProvidersSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Name2CloudProvider = providers
	return resp, nil
}

func (c *Controller) ListCloudRegions(
	ctx context.Context,
	req *coreapi.ListCloudRegionsReq,
) (*coreapi.ListCloudRegionsResp, error) {
	resp := &coreapi.ListCloudRegionsResp{
		Regions:  nil,
		BaseResp: &base.BaseResp{},
	}

	regions, err := c.listCloudRegionsSvc.Query(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Regions = regions
	return resp, nil
}

func (c *Controller) ListNodeProfiles4Tenant(
	ctx context.Context,
	req *coreapi.ListNodeProfiles4TenantReq,
) (*coreapi.ListNodeProfiles4TenantResp, error) {
	resp := &coreapi.ListNodeProfiles4TenantResp{
		Profiles: nil,
		BaseResp: &base.BaseResp{},
	}

	profiles, err := c.listNodeProfiles4TenantSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Profiles = profiles
	return resp, nil
}

func (c *Controller) ChangeClusterPasswd(
	ctx context.Context,
	req *coreapi.ChangeClusterPasswdReq,
) (*coreapi.ChangeClusterPasswdResp, error) {
	resp := &coreapi.ChangeClusterPasswdResp{
		Synced:   false,
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		ClusterID: req.ClusterId,
	})

	synced, err := c.changeClusterPasswdSvc.Change(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Synced = synced
	return resp, nil
}

func (c *Controller) CreateCidr(
	ctx context.Context,
	req *coreapi.CreateCidrRequest,
) (*coreapi.CreateCidrResponse, error) {
	resp := &coreapi.CreateCidrResponse{
		Id:        0,
		Overlaps:  nil,
		MaxNodeIp: 0,
		BaseResp:  &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
	})

	id, overlaps, maxNodeIP, err := c.createCidrSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Id = id
	resp.Overlaps = overlaps
	resp.MaxNodeIp = maxNodeIP
	return resp, nil
}

func (c *Controller) UpdateCidr(
	ctx context.Context,
	req *coreapi.UpdateCidrRequest,
) (*coreapi.UpdateCidrResponse, error) {
	resp := &coreapi.UpdateCidrResponse{
		Overlaps:  nil,
		MaxNodeIp: 0,
		BaseResp:  &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
	})

	overlaps, maxNodeIP, err := c.updateCidrSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Overlaps = overlaps
	resp.MaxNodeIp = maxNodeIP
	return resp, nil
}

func (c *Controller) DeleteCidr(
	ctx context.Context,
	req *coreapi.DeleteCidrRequest,
) (*coreapi.DeleteCidrResponse, error) {
	resp := &coreapi.DeleteCidrResponse{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
	})

	err := c.deleteCidrSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	return resp, nil
}

func (c *Controller) QueryCidrs(
	ctx context.Context,
	req *coreapi.QueryCidrsRequest,
) (*coreapi.QueryCidrsResponse, error) {
	resp := &coreapi.QueryCidrsResponse{
		Items:    nil,
		BaseResp: &base.BaseResp{},
	}

	cidrs, err := c.queryCidrsSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}
	resp.Items = cidrs
	return resp, nil
}

func (c *Controller) GetDefaultCidr(
	ctx context.Context,
	req *coreapi.GetDefaultCidrRequest,
) (*coreapi.GetDefaultCidrResponse, error) {
	resp := &coreapi.GetDefaultCidrResponse{
		DefaultCidr: nil,
		BaseResp:    &base.BaseResp{},
	}

	defaultCIDR, err := c.getDefaultCidrSvc.Execute(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.DefaultCidr = defaultCIDR
	return resp, nil
}

func (c *Controller) GetAwsAccount(
	ctx context.Context,
	req *coreapi.GetAwsAccountReq,
) (*coreapi.GetAwsAccountResp, error) {
	resp := &coreapi.GetAwsAccountResp{
		BaseResp: &base.BaseResp{},
	}

	accountId, err := c.getAwsAccountSvc.GetAccount(ctx, req)
	if err != nil {
		return resp, err
	}
	resp.AwsAccountId = accountId
	return resp, nil
}

func (c *Controller) CreateAwsCmek(
	ctx context.Context,
	req *coreapi.CreateAwsCmekReq,
) (*coreapi.CreateAwsCmekResp, error) {
	resp := &coreapi.CreateAwsCmekResp{
		BaseResp: &base.BaseResp{},
	}

	// gen request meta and append to outgoing meta
	ctx = metadata.AppendToOutgoingMeta(ctx, &metadata.RequestMeta{
		OrgID:            req.OrgId,
		DefaultProjectID: req.ProjectId,
		ValidProjectList: []uint64{req.ProjectId},
	})

	err := c.createAwsCmekSvc.Create(ctx, req)
	if err != nil {
		return resp, err
	}
	return resp, nil
}

func (c *Controller) GetAwsCmek(ctx context.Context, req *coreapi.GetAwsCmekReq) (*coreapi.GetAwsCmekResp, error) {
	resp := &coreapi.GetAwsCmekResp{
		BaseResp: &base.BaseResp{},
	}

	cmeks, err := c.listAwsCmekSvc.Listcmek(ctx, req)
	if err != nil {
		return resp, err
	}

	resp.Cmeks = cmeks
	return resp, nil
}

func (c *Controller) GetClusterCACertificate(
	ctx context.Context,
	req *coreapi.GetClusterCACertificateReq,
) (*coreapi.GetClusterCACertificateResp, error) {
	resp, err := c.getClusterCACertificateSvc.Get(ctx, req)
	if err != nil {
		return resp, err
	}
	return resp, nil
}