package service

import (
	"github.com/shopspring/decimal"
	"silkserver/constvar"
	"silkserver/extend/code"
	"silkserver/models"
	"sort"
)

type Standard struct {
	CheckItem     constvar.CheckItem
	StartFineness decimal.Decimal
	EndFineness   decimal.Decimal
	GradeMap      map[string]struct{}
	ValueList     []*Pair
	SortType      ValueType
	GradeRank     map[string]int
}

type Pair struct {
	RankName  string
	RankValue decimal.Decimal
}

type ValueType int

const (
	ValueTypeSmallerBetter ValueType = 0 //值按升序排名（值越小，等级越高）
	ValueTypeGreaterBetter ValueType = 1 //值按降序排名（值越大，等级越高）
)

var sortTypeMap = map[constvar.CheckItem]ValueType{
	constvar.CheckItemDeviation:    ValueTypeSmallerBetter,
	constvar.CheckItemTwiceChange:  ValueTypeSmallerBetter,
	constvar.CheckItemCleanliness:  ValueTypeGreaterBetter,
	constvar.CheckItemPurity:       ValueTypeGreaterBetter,
	constvar.CheckItemMaxDeviation: ValueTypeSmallerBetter,
}

func GetSilkRankStandard(startFineness, endFineness decimal.Decimal) (map[string]*Standard, error) {
	rankStandards, err := models.NewRawSilkRankStandardSearch().SetFineness(startFineness, endFineness).FindNotTotal()
	if err != nil {
		return nil, err
	}
	if len(rankStandards) == 0 {
		return nil, code.SilkRankStandardNotSetError
	}
	standardMap := make(map[string]*Standard)
	for _, v := range rankStandards {
		if standardMap[v.LineId] == nil {
			standardMap[v.LineId] = &Standard{
				CheckItem:     v.CheckItem,
				StartFineness: v.StartFineness,
				EndFineness:   v.EndFineness,
				GradeMap:      make(map[string]struct{}),
				ValueList:     make([]*Pair, 0),
			}
		}
		if _, ok := standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeA]; !ok {
			standardMap[v.LineId].ValueList = append(standardMap[v.LineId].ValueList, &Pair{
				RankName:  constvar.BadFinenessGradeA,
				RankValue: v.RankA,
			})
			standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeA] = struct{}{}
		}
		if _, ok := standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeB]; !ok {
			standardMap[v.LineId].ValueList = append(standardMap[v.LineId].ValueList, &Pair{
				RankName:  constvar.BadFinenessGradeB,
				RankValue: v.RankB,
			})
			standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeB] = struct{}{}
		}
		if _, ok := standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeC]; !ok {
			standardMap[v.LineId].ValueList = append(standardMap[v.LineId].ValueList, &Pair{
				RankName:  constvar.BadFinenessGradeC,
				RankValue: v.RankC,
			})
			standardMap[v.LineId].GradeMap[constvar.BadFinenessGradeC] = struct{}{}
		}
		if _, ok := standardMap[v.LineId].GradeMap[v.RankName]; !ok {
			standardMap[v.LineId].ValueList = append(standardMap[v.LineId].ValueList, &Pair{
				RankName:  v.RankName,
				RankValue: v.RankValue,
			})
			standardMap[v.LineId].GradeMap[v.RankName] = struct{}{}
		}
	}
	//value排序
	for k := range standardMap { //等级降序排列
		sort.Slice(standardMap[k].ValueList, func(i, j int) bool {
			sortType := sortTypeMap[standardMap[k].CheckItem]
			standardMap[k].SortType = sortType
			if sortType == ValueTypeSmallerBetter {
				return standardMap[k].ValueList[i].RankValue.LessThan(standardMap[k].ValueList[j].RankValue)
			} else {
				return standardMap[k].ValueList[i].RankValue.GreaterThan(standardMap[k].ValueList[j].RankValue)
			}
		})
	}
	//等级排名 GradeRank越大，等级越高
	for lineId, standard := range standardMap {
		for k, pair := range standard.ValueList {
			if standardMap[lineId].GradeRank == nil {
				standardMap[lineId].GradeRank = make(map[string]int, 0)
			}
			standardMap[lineId].GradeRank[pair.RankName] = len(standard.ValueList) - k
		}
	}
	return standardMap, nil
}