package daytask

import (
	model "go_server/model/biz_modules/daytask"
	"go_server/model/common/response"
	"go_server/service/base"

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

// DtTaskCategoryService 任务分类服务
type DtTaskCategoryService struct {
	base.BizCommonService
}

func (s *DtTaskCategoryService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).Get(c, s.DB())
}

func (s *DtTaskCategoryService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id       *int64  `form:"id"`
		Name     *string `form:"name"`
		Platform *string `form:"platform"`
		Status   *int8   `form:"status"`
	}
	req := new(request[model.DtTaskCategory])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.Name != nil && *req.Name != "" {
		db = db.Where("name LIKE ?", "%"+*req.Name+"%")
	}
	if req.Platform != nil && *req.Platform != "" {
		db = db.Where("platform", req.Platform)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtTaskCategory{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTaskCategory()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskCategoryService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).Create(c, s.DB())
}

func (s *DtTaskCategoryService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).UpdateOne(c, s.DB())
}

func (s *DtTaskCategoryService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).DeleteOne(c, s.DB())
}

// DtTaskService 任务服务
type DtTaskService struct {
	base.BizCommonService
}

func (s *DtTaskService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).Get(c, s.DB())
}

func (s *DtTaskService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id         *int64  `form:"id"`
		TaskNo     *string `form:"taskNo"`
		CategoryId *int64  `form:"categoryId"`
		Title      *string `form:"title"`
		TaskType   *int8   `form:"taskType"`
		Status     *int8   `form:"status"`
		MinLevel   *int    `form:"minLevel"`
		BeginTime  *int64  `form:"beginTime"`
		EndTime    *int64  `form:"endTime"`
	}
	req := new(request[model.DtTask])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.TaskNo != nil && *req.TaskNo != "" {
		db = db.Where("task_no", req.TaskNo)
	}
	if req.CategoryId != nil && *req.CategoryId != 0 {
		db = db.Where("category_id", req.CategoryId)
	}
	if req.Title != nil && *req.Title != "" {
		db = db.Where("title LIKE ?", "%"+*req.Title+"%")
	}
	if req.TaskType != nil {
		db = db.Where("task_type", req.TaskType)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.MinLevel != nil {
		db = db.Where("min_level >= ?", req.MinLevel)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtTask{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTask()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).Create(c, s.DB())
}

func (s *DtTaskService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).UpdateOne(c, s.DB())
}

func (s *DtTaskService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).DeleteOne(c, s.DB())
}

// DtTaskStepService 任务步骤服务
type DtTaskStepService struct {
	base.BizCommonService
}

func (s *DtTaskStepService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).Get(c, s.DB())
}

func (s *DtTaskStepService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		TaskId *int64 `form:"taskId"`
	}
	req := new(request[model.DtTaskStep])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.TaskId != nil && *req.TaskId != 0 {
		db = db.Where("task_id", req.TaskId)
	}
	db = db.Order("step_no ASC, sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtTaskStep{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTaskStep()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskStepService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).Create(c, s.DB())
}

func (s *DtTaskStepService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).UpdateOne(c, s.DB())
}

func (s *DtTaskStepService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).DeleteOne(c, s.DB())
}

// DtUserTaskService 用户任务记录服务
type DtUserTaskService struct {
	base.BizCommonService
}

func (s *DtUserTaskService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).Get(c, s.DB())
}

func (s *DtUserTaskService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id        *int64  `form:"id"`
		OrderNo   *string `form:"orderNo"`
		UserId    *int64  `form:"userId"`
		UserUid   *string `form:"userUid"`
		TaskId    *int64  `form:"taskId"`
		TaskNo    *string `form:"taskNo"`
		Status    *int8   `form:"status"`
		BeginTime *int64  `form:"beginTime"`
		EndTime   *int64  `form:"endTime"`
	}
	req := new(request[model.DtUserTask])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.OrderNo != nil && *req.OrderNo != "" {
		db = db.Where("order_no", req.OrderNo)
	}
	if req.UserId != nil && *req.UserId != 0 {
		db = db.Where("user_id", req.UserId)
	}
	if req.UserUid != nil && *req.UserUid != "" {
		db = db.Where("user_uid", req.UserUid)
	}
	if req.TaskId != nil && *req.TaskId != 0 {
		db = db.Where("task_id", req.TaskId)
	}
	if req.TaskNo != nil && *req.TaskNo != "" {
		db = db.Where("task_no", req.TaskNo)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtUserTask{})
	resp, err := base.NewQueryBaseHandler(model.NewDtUserTask()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtUserTaskService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).Create(c, s.DB())
}

func (s *DtUserTaskService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).UpdateOne(c, s.DB())
}

func (s *DtUserTaskService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).DeleteOne(c, s.DB())
}

// Audit 审核任务
func (s *DtUserTaskService) Audit(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request struct {
		Id           int64  `json:"id" binding:"required"`
		Status       int8   `json:"status" binding:"required"` // 2=通过 3=拒绝
		AuditRemark  string `json:"auditRemark"`
		RejectReason string `json:"rejectReason"`
	}
	var req request
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	if req.Status != 2 && req.Status != 3 {
		response.Resp(c, "状态值无效")
		return
	}

	updates := map[string]interface{}{
		"status":       req.Status,
		"audit_remark": req.AuditRemark,
		"audit_time":   c.GetInt64("now"),
	}
	if req.Status == 3 {
		updates["reject_reason"] = req.RejectReason
	}

	err := s.DB().Model(&model.DtUserTask{}).Where("id = ? AND status = 1", req.Id).Updates(updates).Error
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, "操作成功")
}