crazy_fox_backend_api/service/act_fox_hammer.go

package service

import (
	"fmt"
	"sort"

	"crazy-fox-backend-api/config"
	"crazy-fox-backend-api/model"
	"crazy-fox-backend-api/utils"

	"github.com/jmoiron/sqlx/types"
	jsoniter "github.com/json-iterator/go"
	"github.com/pkg/errors"
)

type actFoxHammer struct{}

// 展示数据处理
func (This *actFoxHammer) handleActShow(confInfo *model.ActConfInfo) (json types.JSONText, err error) {

	var repoConf []model.FoxHammerRepoConf
	if err := jsoniter.Unmarshal(confInfo.Reward, &repoConf); err != nil {
		return nil, errors.Wrap(err, "狐狸之锤 奖励Json解析失败")
	}

	// 数据转换
	showConf := This.convertIntoShowConf(repoConf)
	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "狐狸之锤 奖励序列化失败")
	}

	return
}

// 保存数据处理
func (This *actFoxHammer) handleActSave(confInfo *model.ActConfInfo) (err error) {

	var showConfArr []model.FoxHammerShowConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConfArr); err != nil {
		return errors.Wrap(err, "狐狸之锤 奖励Json解析失败")
	}

	repoConfArr := This.convertIntoRepoConf(showConfArr)
	if confInfo.Reward, err = jsoniter.Marshal(repoConfArr); err != nil {
		return errors.Wrap(err, "狐狸之锤 奖励数据序列化失败")
	}

	return
}

// 分层数据处理
func (This *actFoxHammer) handleActRewardSection(confInfo *model.ActConfInfo, maps ...map[string]any) error {
	var repoConfArr []model.FoxHammerRepoConf
	if err := jsoniter.Unmarshal(confInfo.Reward, &repoConfArr); err != nil {
		return errors.Wrap(err, "狐狸之锤 奖励解析失败")
	}

	conditionMap, rewardMap := maps[0], maps[1]
	for idx1, item1 := range repoConfArr {
		for idx2, item2 := range item1.Data {
			stageKey := fmt.Sprintf("%d_%d", idx1, idx2)

			conditionMap[stageKey] = Activity.buildStageConditionOld(item1.StartEnd, item2.SsGroup)
			rewardMap[stageKey] = item2.Data
		}
	}

	return nil
}

// 导入数据处理
func (This *actFoxHammer) handleActImport(_ *model.ActDetailInfo, excelInfo [][][]string) (json types.JSONText, err error) {
	if len(excelInfo) < 3 {
		return json, errors.New("工作表数量不匹配")
	}

	var showConfArr []model.FoxHammerShowConf
	if showConfArr, err = This.sheetResolver(excelInfo); err != nil {
		return json, errors.Wrap(err, "狐狸之锤 工作表解析失败")
	}

	if json, err = jsoniter.Marshal(showConfArr); err != nil {
		return json, errors.Wrap(err, "狐狸之锤 配置序列化失败")
	}

	return
}

func (This *actFoxHammer) convertIntoShowConf(repoConfArr []model.FoxHammerRepoConf) (showConfArr []model.FoxHammerShowConf) {

	for lvId, lvStage := range repoConfArr {
		for ssId, ssGroupStage := range lvStage.Data {

			showConfArr = append(showConfArr, model.FoxHammerShowConf{
				TwoLayerLvSsGroup: model.TwoLayerLvSsGroup{
					Id:      Activity.buildLayerOrderId(int64(lvId), int64(ssId)),
					LvRange: model.LvRange{LvStart: lvStage.Start, LvEnd: lvStage.End},
					SsGroup: ssGroupStage.SsGroup,
				},
				Stages: This.formatStageConf(ssGroupStage.Data),
			})
		}
	}

	return
}

func (This *actFoxHammer) convertIntoRepoConf(showConfArr []model.FoxHammerShowConf) (repoConfArr []model.FoxHammerRepoConf) {

	ssStageArrMap := This.buildSsStageArrMap(showConfArr)

	repoConfArr = make([]model.FoxHammerRepoConf, 0, len(showConfArr))
	for _, stages := range ssStageArrMap {

		repoConfArr = append(repoConfArr, model.FoxHammerRepoConf{
			StartEnd: model.StartEnd{Start: stages.LvRange.LvStart, End: stages.LvRange.LvEnd},
			Data:     stages.Data,
		})
	}

	return
}

func (This *actFoxHammer) sheetResolver(excelInfo [][][]string) (showConf []model.FoxHammerShowConf, err error) {

	sheet2Array, sheet3Array, sheet4Array := excelInfo[1], excelInfo[2], excelInfo[3]

	// 解析分组ID配置项
	var stageConf []model.TwoLayerLvSsGroup
	if stageConf, err = Activity.parseTwoLayerLvSsGroupConf(sheet2Array); err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析阶段配置项
	var stageArrMap map[int64][]model.FoxHammerTmpStageReward
	if stageArrMap, err = This.parseStageSheet(sheet3Array); err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析概率配置项
	var probArrMap map[int64][]model.FoxHammerProb
	if probArrMap, err = This.parseProbSheet(sheet4Array); err != nil {
		return showConf, errors.WithStack(err)
	}

	if showConf, err = This.packageShowConf(stageConf, stageArrMap, probArrMap); err != nil {
		return showConf, errors.WithStack(err)
	}

	return
}

func (This *actFoxHammer) parseStageSheet(sheet [][]string) (stageArrMap map[int64][]model.FoxHammerTmpStageReward, err error) {

	stageArrMap = map[int64][]model.FoxHammerTmpStageReward{}
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			id     int64
			ignore string
			one    model.FoxHammerTmpStageReward
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &ignore, &one.Ton, &one.Price, &one.ProbId); err != nil {
			return nil, errors.WithStack(err)
		}

		if one.Sku = config.PriceSkuMap[one.Price]; utils.IsEmpty(one.Sku) {
			return nil, errors.New(fmt.Sprintf("第%d行,购买价格：%.2f 无对应sku", rowIdx, one.Price))
		}

		stageArrMap[id] = append(stageArrMap[id], one)
	}

	return
}

func (This *actFoxHammer) parseProbSheet(sheet [][]string) (probArrMap map[int64][]model.FoxHammerProb, err error) {

	probArrMap = map[int64][]model.FoxHammerProb{}
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			id     int64
			ignore string
			one    model.FoxHammerProb
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &ignore, &one.Spins, &one.Weight); err != nil {
			return nil, errors.WithStack(err)
		}

		probArrMap[id] = append(probArrMap[id], one)
	}

	return
}

func (This *actFoxHammer) packageShowConf(layers []model.TwoLayerLvSsGroup, stageArrMap map[int64][]model.FoxHammerTmpStageReward, probArrMap map[int64][]model.FoxHammerProb) (showConfArr []model.FoxHammerShowConf, err error) {

	var Ok bool
	var stageArr []model.FoxHammerTmpStageReward
	var stageReward []model.FoxHammerStageShowReward

	showConfArr = make([]model.FoxHammerShowConf, 0, len(layers))
	for _, layer := range layers {

		if stageArr, Ok = stageArrMap[layer.Id]; !Ok {
			return nil, errors.New(fmt.Sprintf("阶段唯一ID: %d 未配置", layer.Id))
		}

		if stageReward, err = This.buildStageReward(stageArr, probArrMap); err != nil {
			return nil, errors.WithStack(err)
		}

		showConfArr = append(showConfArr, model.FoxHammerShowConf{
			TwoLayerLvSsGroup: layer,
			Stages:            stageReward,
		})
	}

	return
}

func (This *actFoxHammer) formatStageConf(stageRewardArr []model.FoxHammerStageReward) []model.FoxHammerStageShowReward {
	stageShowArr := make([]model.FoxHammerStageShowReward, 0, len(stageRewardArr))
	for _, datum := range stageRewardArr {

		probArr := make([]model.FoxHammerProb, 0, len(datum.Prizes))
		for _, prize := range datum.Prizes {
			probArr = append(probArr, model.FoxHammerProb{
				Weight: prize.Weight,
				Spins:  prize.Reward.Num,
			})
		}
		stageShowArr = append(stageShowArr, model.FoxHammerStageShowReward{
			FoxHammerBaseConf: datum.FoxHammerBaseConf,
			Prob:              probArr,
		})
	}

	return stageShowArr
}

func (This *actFoxHammer) buildSsStageConf(stages []model.FoxHammerStageShowReward) []model.FoxHammerStageReward {

	ssStageConf := make([]model.FoxHammerStageReward, 0, len(stages))
	for idx, stage := range stages {

		var prizes []model.FoxHammerPrize
		stage.Gid = 1846
		stage.Stage = int64(idx + 1)
		stage.IsFree = utils.Ternary(utils.IsEmpty(stage.Price), int64(1), 0)
		stage.SpinsMin, stage.SpinsMax, prizes = This.findSpinsExtremum(stage.Prob)
		ssStageConf = append(ssStageConf, model.FoxHammerStageReward{
			FoxHammerBaseConf: stage.FoxHammerBaseConf,
			Prizes:            prizes,
		})
	}

	return ssStageConf
}

func (This *actFoxHammer) buildSsStageArrMap(showConfArr []model.FoxHammerShowConf) []model.FoxHammerTmpSsConf {

	ssStageArrMap := make(map[model.LvRange][]model.FoxHammerSSGroupStage, 0)
	for i := 0; i < len(showConfArr); i++ {
		oneRowInfo := showConfArr[i]
		ssStageArrMap[oneRowInfo.LvRange] = append(ssStageArrMap[oneRowInfo.LvRange], model.FoxHammerSSGroupStage{
			SsGroup: oneRowInfo.SsGroup,
			Data:    This.buildSsStageConf(oneRowInfo.Stages),
		})
	}

	tmpSsConf := make([]model.FoxHammerTmpSsConf, 0, len(ssStageArrMap))
	for idx, stages := range ssStageArrMap {
		tmpSsConf = append(tmpSsConf, model.FoxHammerTmpSsConf{
			LvRange: idx,
			Data:    stages,
		})
	}

	sort.SliceStable(tmpSsConf, func(i, j int) bool {
		if tmpSsConf[i].LvRange.LvStart != tmpSsConf[j].LvRange.LvStart {
			return tmpSsConf[i].LvRange.LvStart < tmpSsConf[j].LvRange.LvStart
		}

		return tmpSsConf[i].LvRange.LvEnd < tmpSsConf[j].LvRange.LvEnd
	})

	return tmpSsConf
}

func (This *actFoxHammer) findSpinsExtremum(probArr []model.FoxHammerProb) (min int64, max int64, prizes []model.FoxHammerPrize) {

	min = probArr[0].Spins
	prizes = make([]model.FoxHammerPrize, 0, len(probArr))
	for _, prob := range probArr {
		prizes = append(prizes, model.FoxHammerPrize{
			Weight: prob.Weight,
			Reward: model.ActPrize{Type: config.PropSpin, Num: prob.Spins, Rtype: 1, Skin: 0},
		})

		min = utils.Min(min, prob.Spins)
		max = utils.Max(max, prob.Spins)
	}

	return
}

func (This *actFoxHammer) buildStageReward(stageArr []model.FoxHammerTmpStageReward, probArrMap map[int64][]model.FoxHammerProb) ([]model.FoxHammerStageShowReward, error) {

	var Ok bool
	var probArr []model.FoxHammerProb

	stagesReward := make([]model.FoxHammerStageShowReward, 0, len(stageArr))
	for _, reward := range stageArr {
		if probArr, Ok = probArrMap[reward.ProbId]; !Ok {
			return nil, errors.New(fmt.Sprintf("概率唯一ID: %d 未配置", reward.ProbId))
		}
		reward.Prob = probArr
		stagesReward = append(stagesReward, reward.FoxHammerStageShowReward)
	}

	return stagesReward, nil
}