package controllers

import (
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"silkserver/controllers/request"
	"silkserver/controllers/response"
	"silkserver/extend/code"
	"silkserver/extend/util"
	"silkserver/models"
	"silkserver/pkg/snowflake"
	"sort"
	"strconv"
)

type RawSilkStandardController struct {
}

// SavePriceStandard
//
//	@Tags		系统设置/生丝定价标准
//	@Summary	保存生丝定价标准
//	@Produce	application/json
//	@Param		object	body		models.RawSilkPriceStandard	true	"参数"
//	@Success	200		{object}	util.Response		"成功"
//	@Router		/api-jl/v1/system/savePriceStandard [post]
func (slf RawSilkStandardController) SavePriceStandard(c *gin.Context) {
	var priceStandard models.RawSilkPriceStandard
	err := c.BindJSON(&priceStandard)
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	if priceStandard.ID > 0 {
		err = models.NewRawSilkPriceStandardSearch().Save(&priceStandard)
	} else {
		err = models.NewRawSilkPriceStandardSearch().Create(&priceStandard)
	}
	if err != nil {
		util.ResponseFormat(c, code.SaveFail, "保存失败")
		return
	}
	util.ResponseFormat(c, code.Success, "保存成功")
}

// GetPriceStandardList
//
//	@Tags		系统设置/生丝定价标准
//	@Summary	获取生丝定价标准
//	@Produce	application/json
//	@Param		object	query		request.GetPriceStandard	true	"参数"
//	@Success	200		{object}	util.ResponseList{data=[]models.RawSilkPriceStandard}		"成功"
//	@Router		/api-jl/v1/system/getPriceStandardList [get]
func (slf RawSilkStandardController) GetPriceStandardList(c *gin.Context) {
	var param request.GetPriceStandard
	err := c.ShouldBindQuery(&param)
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	list, total, err := models.NewRawSilkPriceStandardSearch().SetPage(param.Page, param.PageSize).Find()
	if err != nil {
		util.ResponseFormat(c, code.SelectError, "查询失败")
		return
	}
	util.ResponseFormatList(c, code.Success, list, total)
}

// DeletePriceStandard
//
//	@Tags		系统设置/生丝定价标准
//	@Summary	删除生丝定价标准
//	@Produce	application/json
//	@Param		id	path		string			true	"id"
//	@Success	200	{object}	util.Response	"成功"
//	@Router		/api-jl/v1/system/deletePriceStandard/{id} [delete]
func (slf RawSilkStandardController) DeletePriceStandard(c *gin.Context) {
	id := c.Param("id")
	if id == "" {
		util.ResponseFormat(c, code.RequestParamError, "无效的id")
		return
	}
	atoi, err := strconv.Atoi(id)
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "数据转换失败")
		return
	}
	err = models.NewRawSilkPriceStandardSearch().SetId(atoi).Delete()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "删除失败")
		return
	}
	util.ResponseFormat(c, code.Success, "删除成功")
}

// GetRankStandard
//
//	@Tags		系统设置/生丝定级标准
//	@Summary	获取生丝定级标准
//	@Produce	application/json
//	@Success	200	{object}	util.ResponseList{data=[]response.RankStandard}	"成功"
//	@Router		/api-jl/v1/system/getRankStandard [get]
func (slf RawSilkStandardController) GetRankStandard(c *gin.Context) {
	standards, err := models.NewRawSilkRankStandardSearch().FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "获取生丝定级标准失败")
		return
	}
	m := make(map[string]response.RankStandard)
	for _, standard := range standards {
		var dr response.DynamicsRank
		dr.RankName = standard.RankName
		dr.RankValue = standard.RankValue
		dr.RankProp = standard.RankProp
		rankStandard, ok := m[standard.LineId]
		if !ok {
			rankStandard.LineId = standard.LineId
			rankStandard.CheckItem = standard.CheckItem
			rankStandard.StartFineness = standard.StartFineness
			rankStandard.EndFineness = standard.EndFineness
			rankStandard.RankA = standard.RankA
			rankStandard.RankB = standard.RankB
			rankStandard.RankC = standard.RankC
		}
		rankStandard.DynamicsRanks = append(rankStandard.DynamicsRanks, dr)
		m[standard.LineId] = rankStandard
	}
	data := make([]response.RankStandard, 0)
	for _, standard := range m {
		data = append(data, standard)
	}
	sort.Slice(data, func(i, j int) bool {
		return data[i].LineId < data[j].LineId
	})
	util.ResponseFormat(c, code.Success, data)
}

// SaveRankStandard
//
//	@Tags		系统设置/生丝定级标准
//	@Summary	保存生丝定级标准
//	@Produce	application/json
//	@Param		object	body		request.SaveRankStandard	true	"参数"
//	@Success	200		{object}	util.Response		"成功"
//	@Router		/api-jl/v1/system/saveRankStandard [post]
func (slf RawSilkStandardController) SaveRankStandard(c *gin.Context) {
	var rankStandard request.SaveRankStandard
	err := c.BindJSON(&rankStandard)
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "参数解析失败，数据类型错误")
		return
	}
	batch := make([]*models.RawSilkRankStandard, 0)
	for _, standard := range rankStandard.RankStandard {
		var rank models.RawSilkRankStandard
		if standard.LineId == "" {
			rank.LineId = snowflake.GenerateIdStr()
		} else {
			rank.LineId = standard.LineId
		}
		rank.CheckItem = standard.CheckItem
		rank.StartFineness = standard.StartFineness
		rank.EndFineness = standard.EndFineness
		rank.RankA = standard.RankA
		rank.RankB = standard.RankB
		rank.RankC = standard.RankC
		for _, dynamicsRank := range standard.DynamicsRanks {
			rs := rank
			rs.RankProp = dynamicsRank.RankProp
			rs.RankName = dynamicsRank.RankName
			rs.RankValue = dynamicsRank.RankValue
			batch = append(batch, &rs)
		}
	}

	err = models.WithTransaction(func(db *gorm.DB) error {
		err = models.NewRawSilkRankStandardSearch().SetOrm(db).DeleteAll()
		if err != nil {
			return err
		}
		if len(batch) > 0 {
			err = models.NewRawSilkRankStandardSearch().SetOrm(db).CreateBatch(batch)
			if err != nil {
				return err
			}
		}
		return nil
	})
	if err != nil {
		util.ResponseFormat(c, code.SaveFail, "保存失败")
		return
	}
	util.ResponseFormat(c, code.Success, "保存成功")
}

// GetRankStandardGrade
//
//	@Tags		系统设置/生丝定级标准
//	@Summary	获取生丝等级
//	@Produce	application/json
//	@Success	200	{object}	util.Response{data=map[string]string}	"成功"
//	@Router		/api-jl/v1/system/getRankStandardGrade [get]
func (slf RawSilkStandardController) GetRankStandardGrade(c *gin.Context) {
	standards, err := models.NewRawSilkRankStandardSearch().FindNotTotal()
	if err != nil {
		util.ResponseFormat(c, code.RequestParamError, "获取生丝等级失败")
		return
	}
	m := make(map[string]string)
	m["野纤"] = "野纤"
	m["大野"] = "大野"
	m["特野"] = "特野"
	for _, standard := range standards {
		m[standard.RankName] = standard.RankName
	}
	util.ResponseFormat(c, code.Success, m)
}