package regionalapi

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/tidbcloud/observability/pkg/common/message"
	"github.com/tidbcloud/observability/pkg/regionalapi/apiinterceptor"
	"github.com/tidbcloud/observability/pkg/regionalservice"
)

// CreateIntegrationTask
// @Summary create an integration task
// @Description create an integration task for data processing
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param request body message.CreateIntegrationTaskReq true "create integration task request"
// @Success 202 {object} message.Result{data=message.CreateIntegrationTaskResp}
// @Success 409 {object} message.Result{data=message.CreateIntegrationTaskResp}
// @Failure 500 {object} message.Result
// @Router /integrationtasks/ [post]
func CreateIntegrationTask(c *gin.Context) {
	req := &message.CreateIntegrationTaskReq{
		BizType:   c.Param("bizType"),
		ClusterID: c.Param("applicationID"),
	}
	headers := &message.OpenCommonHeaders{}
	if apiinterceptor.HandleJsonRequestFromBody(c, req) && apiinterceptor.HandleHeaders(c, headers) {
		req.TenantID = headers.OrgID
		resp, err := regionalservice.GetIntegrationTaskHandler().CreateIntegrationTask(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// DetailIntegrationTask
// @Summary show detail info of an integration task
// @Description show detail info of an integration task
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param id path string true "integration task id"
// @Param request query message.DetailIntegrationTaskReq true "detail integration task request"
// @Success 200 {object} message.Result{data=message.DetailIntegrationTaskResp}
// @Failure 404 {object} message.Result
// @Failure 500 {object} message.Result
// @Router /integrationtasks/{id} [get]
func DetailIntegrationTask(c *gin.Context) {
	req := &message.DetailIntegrationTaskReq{
		ID:        c.Param("id"),
		ClusterID: c.Param("applicationID"),
	}
	if apiinterceptor.HandleJsonRequestFromQuery(c, req) {
		resp, err := regionalservice.GetIntegrationTaskHandler().DetailIntegrationTask(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// DeleteIntegrationTask
// @Summary delete an integration task
// @Description delete an integration task
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param id path string true "integration task id"
// @Param request query message.DeleteIntegrationTaskReq true "delete integration task request"
// @Success 202 {object} message.Result{data=message.DeleteIntegrationTaskResp}
// @Failure 404 {object} message.Result
// @Failure 500 {object} message.Result
// @Router /integrationtasks/{id} [delete]
func DeleteIntegrationTask(c *gin.Context) {
	req := &message.DeleteIntegrationTaskReq{
		ID:        c.Param("id"),
		ClusterID: c.Param("applicationID"),
	}

	if apiinterceptor.HandleJsonRequestFromQuery(c, req) {
		resp, err := regionalservice.GetIntegrationTaskHandler().DeleteIntegrationTask(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusAccepted, resp)
		}
	}
}

// QueryIntegrationTasks
// @Summary query integration tasks
// @Description query integration tasks with filters
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param queryReq query message.QueryIntegrationTasksReq false "query request"
// @Success 200 {object} message.Result{data=message.QueryIntegrationTasksResp}
// @Failure 500 {object} message.Result
// @Router /integrationtasks/ [get]
func QueryIntegrationTasks(c *gin.Context) {
	req := &message.QueryIntegrationTasksReq{
		BizType:   c.Param("bizType"),
		ClusterID: c.Param("applicationID"),
	}
	headers := &message.OpenCommonHeaders{}
	if apiinterceptor.HandleJsonRequestFromQuery(c, req) && apiinterceptor.HandleHeaders(c, headers) {
		req.TenantID = headers.OrgID
		resp, err := regionalservice.GetIntegrationTaskHandler().QueryIntegrationTasks(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// UpdateIntegrationTask
// @Summary update an integration task
// @Description update an integration task
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param id path string true "integration task id"
// @Param request body message.UpdateIntegrationTaskReq true "update integration task request"
// @Success 202 {object} message.Result{data=message.UpdateIntegrationTaskResp}
// @Failure 404 {object} message.Result
// @Failure 500 {object} message.Result
// @Router /integrationtasks/{id} [put]
func UpdateIntegrationTask(c *gin.Context) {
	req := &message.UpdateIntegrationTaskReq{
		ID: c.Param("id"),
	}

	if ok := apiinterceptor.HandleJsonRequestFromBody(c, req); ok {
		resp, err := regionalservice.GetIntegrationTaskHandler().UpdateIntegrationTask(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// CreateIntegrationTaskInternal
// @Summary create an integration task (internal)
// @Description create an integration task for vector agent data processing
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param request body message.CreateIntegrationTaskReq true "create integration task request"
// @Success 202 {object} message.Result{data=message.CreateIntegrationTaskResp}
// @Success 409 {object} message.Result{data=message.CreateIntegrationTaskResp}
// @Failure 500 {object} message.Result
// @Router /monitoringPipelines [post]
func CreateIntegrationTaskInternal(c *gin.Context) {
	req := &message.CreateIntegrationTaskReq{
		BizType:   c.Param("bizType"),
		ClusterID: c.Param("applicationID"),
	}
	headers := &message.OpenCommonHeaders{}
	if apiinterceptor.HandleJsonRequestFromBody(c, req) && apiinterceptor.HandleHeaders(c, headers) {
		req.TenantID = headers.OrgID
		req.UserID = headers.UserID
		resp, err := regionalservice.GetIntegrationTaskHandler().CreateIntegrationTaskInternal(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// DetailIntegrationTaskInternal
// @Summary show detail info of an integration task (internal)
// @Description show detail info of an integration task for internal services
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param id path string true "integration task id"
// @Param request query message.DetailIntegrationTaskReq true "detail integration task request"
// @Success 200 {object} message.Result{data=message.DetailIntegrationTaskResp}
// @Failure 404 {object} message.Result
// @Failure 500 {object} message.Result
// @Router /internal/monitoringPipelines/{id} [get]
func DetailIntegrationTaskInternal(c *gin.Context) {
	req := &message.DetailIntegrationTaskReq{
		ID:        c.Param("id"),
		ClusterID: c.Param("applicationID"),
	}
	if apiinterceptor.HandleJsonRequestFromQuery(c, req) {
		resp, err := regionalservice.GetIntegrationTaskHandler().DetailIntegrationTask(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}

// QueryIntegrationTasksInternal
// @Summary query integration tasks (internal)
// @Description query integration tasks for internal services
// @Tags integrationtask
// @Accept json
// @Produce json
// @Param queryReq query message.QueryIntegrationTasksReq false "query request"
// @Success 200 {object} message.Result{data=message.QueryIntegrationTasksResp}
// @Failure 500 {object} message.Result
// @Router /internal/monitoringPipelines [get]
func QueryIntegrationTasksInternal(c *gin.Context) {
	req := &message.QueryIntegrationTasksReq{
		BizType:   c.Param("bizType"),
		ClusterID: c.Param("applicationID"),
	}
	headers := &message.OpenCommonHeaders{}
	if apiinterceptor.HandleJsonRequestFromQuery(c, req) && apiinterceptor.HandleHeaders(c, headers) {
		req.TenantID = headers.OrgID
		req.UserID = headers.UserID
		resp, err := regionalservice.GetIntegrationTaskHandler().QueryIntegrationTasksInternal(c, *req)
		if err != nil {
			apiinterceptor.OAPIFail(c, err)
		} else {
			c.JSON(http.StatusOK, resp)
		}
	}
}