package gcp

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"sigs.k8s.io/controller-runtime/pkg/client"

	awsiamv1beta1 "github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1"
	computev1alpha1 "github.com/crossplane-contrib/provider-gcp/apis/compute/v1alpha1"
	computev1beta1 "github.com/crossplane-contrib/provider-gcp/apis/compute/v1beta1"
	containerv1beta1 "github.com/crossplane-contrib/provider-gcp/apis/container/v1beta1"
	containerv1beta2 "github.com/crossplane-contrib/provider-gcp/apis/container/v1beta2"
	gcpiamv1alpha1 "github.com/crossplane-contrib/provider-gcp/apis/iam/v1alpha1"
	storagev1alpha1 "github.com/crossplane-contrib/provider-gcp/apis/storage/v1alpha1"
	xpv1beta1 "github.com/crossplane-contrib/provider-gcp/apis/v1beta1"
	vpcpeeringv1beta1 "github.com/crossplane/provider-gcp/apis/vpcpeering/v1beta1"

	bizerr "github.com/tidbcloud/infra-provider/regional-server/pkg/common/errors"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/router/interceptor"
	migrationxpgcp "github.com/tidbcloud/infra-provider/regional-server/pkg/service/migration/crossplane/gcp"
)

type Handler struct {
	svc *migrationxpgcp.Service
}

func NewHandler(svc *migrationxpgcp.Service) *Handler {
	return &Handler{
		svc: svc,
	}
}

func (handler *Handler) ImportAddress(c *gin.Context) {
	cr := new(computev1beta1.Address)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportAddress(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckAddress(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckAddress(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileAddress(c *gin.Context) {
	cr := new(computev1beta1.Address)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportFirewall(c *gin.Context) {
	cr := new(computev1alpha1.Firewall)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportFirewall(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckFirewall(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckFirewall(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileFirewall(c *gin.Context) {
	cr := new(computev1alpha1.Firewall)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportNetwork(c *gin.Context) {
	cr := new(computev1beta1.Network)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportNetwork(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckNetwork(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckNetwork(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileNetwork(c *gin.Context) {
	cr := new(computev1beta1.Network)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportRouter(c *gin.Context) {
	cr := new(computev1alpha1.Router)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportRouter(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckRouter(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckRouter(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileRouter(c *gin.Context) {
	cr := new(computev1alpha1.Router)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportSubnetwork(c *gin.Context) {
	cr := new(computev1beta1.Subnetwork)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportSubnetwork(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckSubnetwork(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckSubnetwork(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileSubnetwork(c *gin.Context) {
	cr := new(computev1beta1.Subnetwork)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportCluster(c *gin.Context) {
	cr := new(containerv1beta2.Cluster)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportCluster(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckCluster(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckCluster(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileCluster(c *gin.Context) {
	cr := new(containerv1beta2.Cluster)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportNodePool(c *gin.Context) {
	cr := new(containerv1beta1.NodePool)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportNodePool(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckNodePool(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckNodePool(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileNodePool(c *gin.Context) {
	cr := new(containerv1beta1.NodePool)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportProviderConfig(c *gin.Context) {
	cr := new(xpv1beta1.ProviderConfig)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportProviderConfig(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportServiceAccountKey(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccountKey)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportServiceAccountKey(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckServiceAccountKey(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckServiceAccountKey(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileServiceAccountKey(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccountKey)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportServiceAccountPolicy(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccountPolicy)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportServiceAccountPolicy(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckServiceAccountPolicy(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckServiceAccountPolicy(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileServiceAccountPolicy(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccountPolicy)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportServiceAccount(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccount)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportServiceAccount(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckServiceAccount(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckServiceAccount(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileServiceAccount(c *gin.Context) {
	cr := new(gcpiamv1alpha1.ServiceAccount)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportBucketPolicyMember(c *gin.Context) {
	cr := new(storagev1alpha1.BucketPolicyMember)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportBucketPolicyMember(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckBucketPolicyMember(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckBucketPolicyMember(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileBucketPolicyMember(c *gin.Context) {
	cr := new(storagev1alpha1.BucketPolicyMember)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportPeering(c *gin.Context) {
	cr := new(vpcpeeringv1beta1.Peering)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportPeering(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckPeering(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckPeering(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcilePeering(c *gin.Context) {
	cr := new(vpcpeeringv1beta1.Peering)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportOIDCProivder(c *gin.Context) {
	cr := new(awsiamv1beta1.OpenIDConnectProvider)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportOIDCProvider(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckOIDCProvider(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckOIDCProvider(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileOIDCProvider(c *gin.Context) {
	cr := new(awsiamv1beta1.OpenIDConnectProvider)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportPolicy(c *gin.Context) {
	cr := new(awsiamv1beta1.Policy)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportPolicy(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckPolicy(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckPolicy(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcilePolicy(c *gin.Context) {
	cr := new(awsiamv1beta1.Policy)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportRolePolicyAttachment(c *gin.Context) {
	cr := new(awsiamv1beta1.RolePolicyAttachment)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportRolePolicyAttachment(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckRolePolicyAttachment(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckRolePolicyAttachment(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileRolePolicyAttachment(c *gin.Context) {
	cr := new(awsiamv1beta1.RolePolicyAttachment)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportRole(c *gin.Context) {
	cr := new(awsiamv1beta1.Role)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportRole(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) CheckRole(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckRole(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ReconcileRole(c *gin.Context) {
	cr := new(awsiamv1beta1.Role)
	cr.Namespace = c.Query("namespace")
	cr.Name = c.Query("name")
	pause, err := strconv.ParseBool(c.Query("pause"))
	if err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.PauseReconcile(c, cr, pause); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}