// Package controllers/pms_controller.go
package controllers

import (
	"Quincy_admin/schemas"
	"Quincy_admin/services"
	"Quincy_admin/utils"
	"fmt"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type CronController struct {
	CronService *services.CronService
}

func NewCronController(CronService *services.CronService) *CronController {
	return &CronController{CronService: CronService}
}

// GetCronList 定时任务列表
// @Summary 定时任务列表
// @Description 定时任务列表
// @Tags 任务管理
// @Accept json
// @Produce json
// @Param req body schemas.CronListRequest true "定时任务"
// @Success 200 {object} schemas.CronListResponse "定时任务"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /cron/list [post]
// @Security ApiKeyAuth
func (c *CronController) GetCronList(ctx *gin.Context) {
	var req schemas.CronListRequest

	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数错误")
		return
	}

	if req.PageIndex <= 0 || req.PageSize <= 0 || req.PageSize > 100 {
		utils.Error(ctx, http.StatusBadRequest, "分页参数错误")
		return
	}

	items, total, err := c.CronService.GetCronList(&req)
	if err != nil {
		fmt.Println("获取用户列表时出错:", err)
		utils.Error(ctx, http.StatusInternalServerError, "获取用户列表失败: "+err.Error())
		return
	}

	response := schemas.CronListResponse{
		Item:      items,
		Total:     total,
		PageIndex: req.PageIndex,
		PageSize:  req.PageSize,
	}

	utils.Success(ctx, response)
}

// HandleCron 	新增/更新任务
// @Summary		新增/更新任务
// @Description	新增/更新任务
// @Tags		任务管理
// @Accept		json
// @Produce		json
// @Param		req	body		schemas.CronJobUpdateRequest	true	"新增/更新任务"
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/cron/hand [post]
// @Security ApiKeyAuth
func (c *CronController) HandleCron(ctx *gin.Context) {
	var req schemas.CronJobUpdateRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数错误")
		return
	}

	// 根据ID值判断是新增还是更新
	if req.ID > 0 {
		// 更新操作
		err := c.CronService.UpdateCron(&req)
		if err != nil {
			utils.Error(ctx, http.StatusInternalServerError, "更新任务失败: "+err.Error())
			return
		}

		utils.Success(ctx, "更新成功")
	} else {
		// 新增操作
		if _, err := c.CronService.AddCron(&req); err != nil {
			utils.Error(ctx, http.StatusInternalServerError, "添加任务失败: "+err.Error())
			return
		}
		utils.Success(ctx, "新增成功")
	}

}

// StopOrStartCron 	启用/停用任务
// @Summary		启用/停用任务
// @Description	启用/停用任务
// @Tags		任务管理
// @Accept		json
// @Produce		json
// @Param		id	path		string	true	"id"
// @Param		enabled	query		int	false	"启用状态(1:启用,0:停用)"
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/cron/{id} [put]
// @Security ApiKeyAuth
func (c *CronController) StopOrStartCron(ctx *gin.Context) {
	var idstr = ctx.Param("id")

	id, err := strconv.Atoi(idstr)
	if err != nil || id <= 0 {
		utils.Error(ctx, http.StatusBadRequest, "参数 id 必须是有效的整数")
		return
	}

	enableStr := ctx.Query("enabled")
	if enableStr == "" {
		utils.Error(ctx, http.StatusBadRequest, "参数 enabled 不能为空")
		return
	}

	enableValue, err := strconv.Atoi(enableStr)
	if err != nil || (enableValue != 0 && enableValue != 1) {
		utils.Error(ctx, http.StatusBadRequest, "参数 enabled 必须是0或1")
		return
	}

	// 直接传递整数值到服务层
	if err := c.CronService.UpdateCronStatus(id, enableValue); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "更新任务状态失败: "+err.Error())
		return
	}

	if enableValue == 1 {
		utils.Success(ctx, "启用成功")
	} else {
		utils.Success(ctx, "停用成功")
	}
}

// DeleteCron 	删除定时任务
// @Summary		删除定时任务
// @Description	删除定时任务
// @Tags		任务管理
// @Accept		json
// @Produce		json
// @Param		id	path		string	true	"id（任务ID）"
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/cron/{id} [delete]
// @Security ApiKeyAuth
func (c *CronController) DeleteCron(ctx *gin.Context) {
	var idstr = ctx.Param("id")

	id, err := strconv.Atoi(idstr)
	if err != nil || id <= 0 {
		utils.Error(ctx, http.StatusBadRequest, "参数 id 必须是有效的正整数")
		return
	}

	if err := c.CronService.DeleteCron(id); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "删除任务失败: "+err.Error())
		return
	}

	utils.Success(ctx, "删除成功")
}

// RestartCron 	重启定时任务
// @Summary		重启定时任务
// @Description	重启定时任务
// @Tags		任务管理
// @Accept		json
// @Produce		json
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/cron/restart [get]
// @Security ApiKeyAuth
func (c *CronController) RestartCron(ctx *gin.Context) {
	if err := c.CronService.RestartCron(); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "重启调度器失败: "+err.Error())
		return
	}

	utils.Success(ctx, "重启成功")
}

// StopCron 	停止所有任务
// @Summary		停止所有任务
// @Description	停止所有任务
// @Tags		任务管理
// @Accept		json
// @Produce		json
// @Success		200		{object}	utils.Response{data=string}
// @Failure		400		{object}	utils.Response
// @Failure		500		{object}	utils.Response
// @Router		/cron/stop [get]
// @Security ApiKeyAuth
func (c *CronController) StopCron(ctx *gin.Context) {
	if err := c.CronService.StopCron(); err != nil {
		utils.Error(ctx, http.StatusInternalServerError, "调度器停止失败: "+err.Error())
		return
	}

	utils.Success(ctx, "停止成功")
}

// GetCronLogList 查看日志运行记录
// @Summary 查看日志运行记录
// @Description 查看日志运行记录
// @Tags 任务管理
// @Accept json
// @Produce json
// @Param req body schemas.CronJobLogListRequest true "req"
// @Success 200 {object} schemas.CronJobLog "res"
// @Failure 400 {object} utils.Response
// @Failure 404 {object} utils.Response
// @Failure 500 {object} utils.Response
// @Router /cron/loglist [post]
// @Security ApiKeyAuth
func (c *CronController) GetCronLogList(ctx *gin.Context) {
	var req schemas.CronJobLogListRequest

	if err := ctx.ShouldBindJSON(&req); err != nil {
		utils.Error(ctx, http.StatusBadRequest, "参数错误")
		return
	}

	if req.PageIndex <= 0 || req.PageSize <= 0 || req.PageSize > 100 {
		utils.Error(ctx, http.StatusBadRequest, "分页参数错误")
		return
	}

	items, total, err := c.CronService.GetCronLogList(&req)
	if err != nil {
		fmt.Println("获取列表时出错:", err)
		utils.Error(ctx, http.StatusInternalServerError, "获取列表失败: "+err.Error())
		return
	}

	response := schemas.CronJobLogListResponse{
		Item:      items,
		Total:     total,
		PageIndex: req.PageIndex,
		PageSize:  req.PageSize,
	}

	utils.Success(ctx, response)
}