package aws

import (
	"net/http"
	"strconv"

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

	ec2v1alpha1 "github.com/crossplane-contrib/provider-aws/apis/ec2/v1alpha1"
	ec2v1beta1 "github.com/crossplane-contrib/provider-aws/apis/ec2/v1beta1"
	"github.com/crossplane-contrib/provider-aws/apis/eks/manualv1alpha1"
	eksv1beta1 "github.com/crossplane-contrib/provider-aws/apis/eks/v1beta1"
	iamv1alpha1 "github.com/crossplane-contrib/provider-aws/apis/iam/v1alpha1"
	iamv1beta1 "github.com/crossplane-contrib/provider-aws/apis/iam/v1beta1"
	route53v1alpha1 "github.com/crossplane-contrib/provider-aws/apis/route53/v1alpha1"
	xpv1beta1 "github.com/crossplane-contrib/provider-aws/apis/v1beta1"
	bizerr "github.com/tidbcloud/infra-provider/regional-server/pkg/common/errors"
	"github.com/tidbcloud/infra-provider/regional-server/pkg/router/interceptor"
	migrationxpaws "github.com/tidbcloud/infra-provider/regional-server/pkg/service/migration/crossplane/aws"
)

type Handler struct {
	svc *migrationxpaws.Service
}

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

func (handler *Handler) ImportCluster(c *gin.Context) {
	cr := new(eksv1beta1.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(eksv1beta1.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) ImportVPC(c *gin.Context) {
	cr := new(ec2v1beta1.VPC)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportVPC(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileVPC(c *gin.Context) {
	cr := new(ec2v1beta1.VPC)
	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) CheckProviderConfig(c *gin.Context) {
	key := client.ObjectKey{
		Namespace: c.Query("namespace"),
		Name:      c.Query("name"),
	}
	if err := handler.svc.CheckProviderConfig(c, key); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

func (handler *Handler) ImportAddress(c *gin.Context) {
	cr := new(ec2v1beta1.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(ec2v1beta1.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) ImportInternetGateway(c *gin.Context) {
	cr := new(ec2v1beta1.InternetGateway)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportInternetGateway(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileInternetGateway(c *gin.Context) {
	cr := new(ec2v1beta1.InternetGateway)
	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) ImportLaunchTemplate(c *gin.Context) {
	cr := new(ec2v1alpha1.LaunchTemplate)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportLaunchTemplate(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileLaunchTemplate(c *gin.Context) {
	cr := new(ec2v1alpha1.LaunchTemplate)
	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) ImportNATGateway(c *gin.Context) {
	cr := new(ec2v1beta1.NATGateway)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportNATGateway(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileNATGateway(c *gin.Context) {
	cr := new(ec2v1beta1.NATGateway)
	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) ImportRoute(c *gin.Context) {
	cr := new(ec2v1alpha1.Route)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportRoute(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileRoute(c *gin.Context) {
	cr := new(ec2v1alpha1.Route)
	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) ImportRouteTable(c *gin.Context) {
	cr := new(ec2v1beta1.RouteTable)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportRouteTable(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileRouteTable(c *gin.Context) {
	cr := new(ec2v1beta1.RouteTable)
	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) ImportSecurityGroup(c *gin.Context) {
	cr := new(ec2v1beta1.SecurityGroup)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportSecurityGroup(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileSecurityGroup(c *gin.Context) {
	cr := new(ec2v1beta1.SecurityGroup)
	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) ImportSubnet(c *gin.Context) {
	cr := new(ec2v1beta1.Subnet)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportSubnet(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileSubnet(c *gin.Context) {
	cr := new(ec2v1beta1.Subnet)
	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) ImportVPCEndpoint(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCEndpoint)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportVPCEndpoint(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileVPCEndpoint(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCEndpoint)
	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) ImportVPCEndpointServiceConfiguration(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCEndpointServiceConfiguration)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportVPCEndpointServiceConfiguration(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileVPCEndpointServiceConfiguration(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCEndpointServiceConfiguration)
	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) ImportNodeGroup(c *gin.Context) {
	cr := new(manualv1alpha1.NodeGroup)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportNodeGroup(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileNodeGroup(c *gin.Context) {
	cr := new(manualv1alpha1.NodeGroup)
	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) ImportInstanceProfile(c *gin.Context) {
	cr := new(iamv1alpha1.InstanceProfile)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportInstanceProfile(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileInstanceProfile(c *gin.Context) {
	cr := new(iamv1alpha1.InstanceProfile)
	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(iamv1beta1.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(iamv1beta1.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(iamv1beta1.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(iamv1beta1.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(iamv1beta1.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(iamv1beta1.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{}{})
}

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

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

func (handler *Handler) ReconcileResourceRecordSet(c *gin.Context) {
	cr := new(route53v1alpha1.ResourceRecordSet)
	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) ImportVPCPeeringConnection(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCPeeringConnection)
	if err := c.BindJSON(cr); err != nil {
		interceptor.Fail(c, bizerr.New(bizerr.ParamParseError, err.Error()))
		return
	}
	if err := handler.svc.ImportVPCPeeringConnection(c, cr); err != nil {
		interceptor.Fail(c, err)
		return
	}
	interceptor.Succeed(c, http.StatusAccepted, struct{}{})
}

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

func (handler *Handler) ReconcileVPCPeeringConnection(c *gin.Context) {
	cr := new(ec2v1alpha1.VPCPeeringConnection)
	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{}{})
}