package controllers

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"silkserver/constvar"
	"silkserver/controllers/request"
	"silkserver/extend/code"
	"silkserver/extend/util"
	"silkserver/models"
	"silkserver/pkg/convertx"
	"silkserver/pkg/structx"
	"strconv"
)

type DictController struct{}

// Add
// @Tags      系统设置/字典
// @Summary   添加字典
// @Produce   application/json
// @Param     object  body  request.AddDict true  "字典信息"
// @Success   200 {object} util.Response "成功"
// @Router    /api-jl/v1/system/dict [post]
func (slf DictController) Add(c *gin.Context) {
	var reqParams request.AddDict
	var params models.Dict
	if err := c.BindJSON(&reqParams); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if err := structx.AssignTo(reqParams, &params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "数据转换错误")
		return
	}

	if err := slf.ParamsCheck(params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, err.Error())
		return
	}
	if err := models.NewDictSearch().Create(&params); err != nil {
		util.ResponseFormat(c, code.SaveFail, "插入失败")
		return
	}

	util.ResponseFormat(c, code.Success, "添加成功")
}

// Update
// @Tags      系统设置/字典
// @Summary   编辑字典
// @Produce   application/json
// @Param     object  body request.UpdateDict true  "字典信息"
// @Success   200 {object} util.Response "成功"
// @Router    /api-jl/v1/system/dict [put]
func (slf DictController) Update(c *gin.Context) {
	var (
		reqParams request.UpdateDict
		params    models.Dict
	)
	if err := c.BindJSON(&reqParams); err != nil {
		util.ResponseFormat(c, code.RequestParamError, fmt.Sprintf("参数解析失败: %v"+err.Error()))
		return
	}
	if err := structx.AssignTo(reqParams, &params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, fmt.Sprintf("数据转换错误: %v", err.Error()))
		return
	}
	if err := slf.ParamsCheck(params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, err.Error())
		return
	}

	_, err := models.NewDictSearch().SetID(params.ID).First()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "ID不存在")
		return
	}

	err = models.NewDictSearch().SetID(params.ID).Save(&params)

	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "修改失败")
		return
	}

	util.ResponseFormat(c, code.UpdateSuccess, "更新成功")
}

func (slf DictController) ParamsCheck(params models.Dict) (err error) {
	if params.Name == "" {
		return errors.New("参数缺失")
	}
	dict, err := models.NewDictSearch().SetName(params.Name).First()
	if err != gorm.ErrRecordNotFound && dict != nil && dict.ID != params.ID {
		return errors.New("名称重复")
	}
	if params.Number != "" {
		dict, err := models.NewDictSearch().SetDictType(params.DictType).SetNumber(params.Number).First()
		if err != gorm.ErrRecordNotFound && dict != nil && dict.ID != params.ID {
			return errors.New("编号重复")
		}
	}
	return nil
}

// List
// @Tags      系统设置/字典
// @Summary   查询字典列表
// @Produce   application/json
// @Param     object  query    request.GetDictList true  "查询参数"
// @Success   200   {object}  util.ResponseList{data=[]models.Dict}  "成功"
// @Router    /api-jl/v1/system/dict [get]
func (slf DictController) List(c *gin.Context) {
	var params request.GetDictList
	if err := c.ShouldBindQuery(&params); err != nil {
		util.ResponseFormat(c, code.RequestParamError, err.Error())
		return
	}

	search := models.NewDictSearch()
	if params.DictType > 0 {
		search = search.SetDictType(params.DictType)
	}
	list, err := search.SetKeyword(params.Keyword).FindAll()

	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "查找失败")
		return
	}

	util.ResponseFormatList(c, code.Success, list, len(list))
}

// Delete
// @Tags      系统设置/字典
// @Summary   删除字典
// @Produce   application/json
// @Param     id  path string true  "字典信息"
// @Success   200 {object} util.Response "成功"
// @Router    /api-jl/v1/system/dict/{id} [delete]
func (slf DictController) Delete(c *gin.Context) {
	idStr := c.Param("id")
	if idStr == "0" || idStr == "" {
		util.ResponseFormat(c, code.RequestParamError, "空的记录id")
		return
	}

	id := convertx.StringToUInt(idStr)
	if id == 0 {
		util.ResponseFormat(c, code.RequestParamError, "空的记录id")
		return
	}
	err := models.NewDictSearch().SetID(id).Delete()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "删除失败")
		return
	}
	util.ResponseFormat(c, code.UpdateSuccess, "删除成功")
}

// GetAutoCode
//
// @Tags	系统设置/字典
// @Summary	获取自动编码
// @Produce	application/json
// @Param   Authorization	header string true "token"
// @Param   object  query    request.CodeStandard true  "查询参数"
// @Success	200	{object}	util.Response{data=map[string]interface{}}
// @Router	/api-jl/v1/system/getAutoCode [get]
func (slf *DictController) GetAutoCode(c *gin.Context) {
	var params request.CodeStandard
	var (
		id     = 0
		prefix = ""
		err    error
	)
	if params.Type, err = strconv.Atoi(c.Query("type")); err != nil {
		util.ResponseFormat(c, code.RequestParamError, "请输入正确的类型")
		return
	}
	switch constvar.CodeStandardType(params.Type) {
	case constvar.CodeStandardType_Workshop:
		id, err = models.NewWorkshopManageSearch().MaxAutoIncr()
		prefix = "CJ"
	case constvar.CodeStandardType_Fineness:
		id, err = models.NewFinenessRegisterSearch().MaxAutoIncr()
		prefix = "XD"
	case constvar.CodeStandardType_Yield:
		id, err = models.NewYieldRegisterSearch().MaxAutoIncr()
		prefix = "CL"
	default:
		util.ResponseFormat(c, code.RequestParamError, "编码规则不存在")
		return
	}
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "获取最大值失败")
		return
	}
	m := make(map[string]interface{})

	strMaxAutoIncr := strconv.Itoa(id + 1)
	count := 8 - len(strMaxAutoIncr)
	for i := 0; i < count; i++ {
		strMaxAutoIncr = "0" + strMaxAutoIncr
	}

	m["id"] = prefix + strMaxAutoIncr
	m["codeStandardID"] = constvar.CodeStandardType_Fineness
	m["maxAutoIncr"] = id + 1
	util.ResponseFormat(c, code.Success, m)
}