crazy_fox_backend_api/service/act_super_gashapon.go

package service

import (
	"fmt"
	"sort"

	"crazy-fox-backend-api/config"

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

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

const (
	normalPrize = int64(0)
	bigPrize    = int64(1)
	luckyPrize  = int64(2)
)

type actSuperGashapon struct{}

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

	var repoConf map[int64]model.SuperGashaponRepoConf
	if err = jsoniter.Unmarshal(confInfo.Reward, &repoConf); err != nil {
		return json, errors.Wrap(err, "超级扭蛋 奖励Json解析失败")
	}

	var repoTokenGoodsConf map[string]model.TokenGoods
	if err = jsoniter.Unmarshal(confInfo.ExtraData, &repoTokenGoodsConf); err != nil {
		return json, errors.Wrap(err, "超级扭蛋 代币商品Json解析失败")
	}

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

	return
}

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

	var showConf []model.SuperGashaponShowConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConf); err != nil {
		return errors.Wrap(err, "超级扭蛋 奖励Json解析失败")
	}

	// 数据合法性验证
	if err = This.verifyConf(showConf); err != nil {
		return errors.WithStack(err)
	}

	repoConf := This.convertIntoRepoConf(showConf)
	if confInfo.Reward, err = jsoniter.Marshal(repoConf); err != nil {
		return errors.Wrap(err, "超级扭蛋 奖励序列化失败")
	}

	if confInfo.ExtraData, err = This.convertTokenGoodsIntoRepoConf(showConf); err != nil {
		return errors.Wrap(err, "超级扭蛋 奖励序列化失败")
	}

	return
}

// 分层数据处理
func (This *actSuperGashapon) handleActRewardSection(confInfo *model.ActConfInfo, maps ...map[string]any) error {

	var repoConf map[int64]model.SuperGashaponRepoConf
	if err := jsoniter.Unmarshal(confInfo.Reward, &repoConf); err != nil {
		return errors.Wrap(err, "超级扭蛋 奖励Json解析失败")
	}

	var extraRewardRepoConfMap map[string]model.TokenGoods
	if err := jsoniter.Unmarshal(confInfo.ExtraData, &extraRewardRepoConfMap); err != nil {
		return errors.Wrap(err, "皮纳塔奖励解析失败")
	}

	conditionMap, rewardMap, extraRewardMap := maps[0], maps[1], maps[2]
	for idx1, item1 := range repoConf {
		for idx2, item2 := range item1.Stages {
			for idx3, item3 := range item2.Stages {
				stageKey := fmt.Sprintf("%d_%d_%d", idx1, idx2, idx3)

				conditionMap[stageKey] = Activity.buildStageCondition(item1.LvRange, item2.SpinsRange, item3.SsGroup)
				rewardMap[stageKey] = item3.Reward

				extraRewardMap[stageKey] = model.StageExtraRepoConf{TokenGoods: extraRewardRepoConfMap[stageKey]}
			}
		}
	}

	return nil
}

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

	var showConfArr []model.SuperGashaponShowConf
	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 *actSuperGashapon) convertIntoShowConf(repoConfMap map[int64]model.SuperGashaponRepoConf, repoTokenGoodsConf map[string]model.TokenGoods) (showConfArr []model.SuperGashaponShowConf) {
	for lvId, lvStageReward := range repoConfMap {
		for spinsId, spinsStageReward := range lvStageReward.Stages {
			for ssId, ssStageReward := range spinsStageReward.Stages {
				stagekey := fmt.Sprintf("%d_%d_%d", lvId, spinsId, ssId)
				showConfArr = append(showConfArr, model.SuperGashaponShowConf{
					ThreeLayer: model.ThreeLayer{
						Id:         Activity.buildLayerOrderId(lvId, spinsId, ssId),
						LvRange:    lvStageReward.LvRange,
						SpinsRange: spinsStageReward.SpinsRange,
						SsGroup:    ssStageReward.SsGroup,
					},
					Reward:     utils.MapValues(ssStageReward.Reward, true),
					TokenGoods: repoTokenGoodsConf[stagekey],
				})
			}
		}
	}
	sort.SliceStable(showConfArr, func(i, j int) bool { return showConfArr[i].Id < showConfArr[j].Id })

	return
}

func (This *actSuperGashapon) verifyConf(showConfArr []model.SuperGashaponShowConf) (err error) {
	for i := 0; i < len(showConfArr); i++ {

		prizeStat := make(map[int64][]int)
		for j := 0; j < len(showConfArr[i].Reward); j++ {
			oneRewardInfo := showConfArr[i].Reward[j]

			if oneRewardInfo.GashType != luckyPrize {
				if len(oneRewardInfo.Prize) != 1 {
					return Activity.jointError("非幸运蛋奖励必须配置且唯一", i+1, j+1)
				}
			} else {
				if len(oneRewardInfo.Prize) != 0 {
					return Activity.jointError("幸运蛋不能配置奖励", i+1, j+1)
				}
			}

			prizeStat[oneRewardInfo.Layer] = append(prizeStat[oneRewardInfo.Layer], utils.Ternary(oneRewardInfo.GashType == luckyPrize, 1, 0))
		}

		for layer, stats := range prizeStat {
			errPrefix := fmt.Sprintf("第 %d 行，第 %d 层，", i+1, layer)

			// 幸运蛋最多只能有一个
			if utils.SliceSum(stats) > 1 {
				return Activity.jointError(utils.Concat(errPrefix, "每层幸运蛋最多一个"))
			}

			// 总奖励数最多10个
			if len(stats) > 10 {
				return Activity.jointError(utils.Concat(errPrefix, "每层扭蛋不能超10个"))
			}
		}
	}

	return
}

func (This *actSuperGashapon) convertIntoRepoConf(showConfArr []model.SuperGashaponShowConf) (repoConfMap map[int64]model.SuperGashaponRepoConf) {

	repoConfMap = map[int64]model.SuperGashaponRepoConf{}

	var unique = uniqid.GetUniqId()
	defer uniqid.DelMapByUniqId(unique)

	for i := 0; i < len(showConfArr); i++ {
		oneRowInfo := showConfArr[i]

		idxes := uniqid.GetStageIdx(unique, oneRowInfo.LvRange, oneRowInfo.SpinsRange, oneRowInfo.SsGroup)
		lvIdx, spinIdx, ssIdx := idxes[0], idxes[1], idxes[2]

		if _, Ok := repoConfMap[lvIdx]; !Ok {
			repoConfMap[lvIdx] = model.SuperGashaponRepoConf{
				LvRange: oneRowInfo.LvRange,
				Stages:  map[int64]model.SuperGashaponSpinsStage{},
			}
		}

		if _, Ok := repoConfMap[lvIdx].Stages[spinIdx]; !Ok {
			repoConfMap[lvIdx].Stages[spinIdx] = model.SuperGashaponSpinsStage{
				SpinsRange: oneRowInfo.SpinsRange,
				Stages:     map[int64]model.SuperGashaponSsStage{},
			}
		}

		repoConfMap[lvIdx].Stages[spinIdx].Stages[ssIdx] = model.SuperGashaponSsStage{
			SsGroup: oneRowInfo.SsGroup,
			Reward:  utils.Slice2Map(oneRowInfo.Reward),
		}
	}

	return
}

func (This *actSuperGashapon) convertTokenGoodsIntoRepoConf(showConfArr []model.SuperGashaponShowConf) (types.JSONText, error) {

	repoConfMap := map[string]model.TokenGoods{}
	var unique = uniqid.GetUniqId()
	defer uniqid.DelMapByUniqId(unique)

	for i := 0; i < len(showConfArr); i++ {
		oneRowInfo := showConfArr[i]

		idxes := uniqid.GetStageIdx(unique, oneRowInfo.LvRange, oneRowInfo.SpinsRange, oneRowInfo.SsGroup)
		lvIdx, spinIdx, ssIdx := idxes[0], idxes[1], idxes[2]
		stageKey := fmt.Sprintf("%d_%d_%d", lvIdx, spinIdx, ssIdx)
		repoConfMap[stageKey] = oneRowInfo.TokenGoods
	}

	return jsoniter.Marshal(repoConfMap)
}

func (This *actSuperGashapon) sheetResolver(sheetList [][][]string) ([]model.SuperGashaponShowConf, error) {

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

	// 解析分组ID配置项
	stageConfArr, err := Activity.parseThreeLayerConf(sheet2Array)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	// 解析奖励配置项
	rewardMap, err := This.parseRewardSheet(sheet3Array)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	// 解析奖励配置项
	tokenGoodsMap, err := Activity.ParseTokenGoodsSheet(sheet4Array, config.ActSuperGashapon)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	showConfArr, err := This.packageShowConf(stageConfArr, rewardMap, tokenGoodsMap)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	return showConfArr, nil
}

func (This *actSuperGashapon) parseRewardSheet(rewardsSheet [][]string) (map[int64][]model.SuperGashaponStageReward, error) {

	var err error
	stageRewardArrMap := map[int64][]model.SuperGashaponStageReward{}

	gashTypeMap := map[string]int64{"普通": 0, "大奖": 1, "幸运蛋": 2}

	for rowIdx := 1; rowIdx < len(rewardsSheet); rowIdx++ {

		var (
			id       int64
			gashType string
			reward   = make([]model.ExcelPrize, 1)
			one      model.SuperGashaponStageReward
		)

		// 解析行配置
		if err = utils.DestructAssign(rewardsSheet[rowIdx], &id, &one.Layer, &gashType, &one.Weight, &one.NeedCoins, &reward); err != nil {
			return nil, errors.WithStack(err)
		}

		if gashTye, Ok := gashTypeMap[gashType]; !Ok {
			return nil, errors.New("未配置奖励类型 唯一ID:" + rewardsSheet[rowIdx][0])
		} else {
			one.GashType = gashTye
		}

		one.Prize = []model.ActPrize{}
		if one.GashType != luckyPrize {
			if one.Prize, err = Props.MultiParseActPrize(reward); err != nil {
				return nil, errors.WithStack(err)
			}
		}

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

	return stageRewardArrMap, nil
}

func (This *actSuperGashapon) packageShowConf(layers []model.ThreeLayer, rewardMap map[int64][]model.SuperGashaponStageReward, tokenGoodsMap map[int64]model.TokenGoods) (showConfArr []model.SuperGashaponShowConf, err error) {

	showConfArr = make([]model.SuperGashaponShowConf, 0, len(layers))
	for _, layer := range layers {
		reward, Ok := rewardMap[layer.Id]
		if !Ok {
			return showConfArr, errors.New("未配置奖励项")
		}

		tokenGoods, Ok := tokenGoodsMap[layer.Id]
		if !Ok {
			return showConfArr, errors.New("未配置代币商品项")
		}
		showConfArr = append(showConfArr, model.SuperGashaponShowConf{
			ThreeLayer: layer,
			Reward:     reward,
			TokenGoods: tokenGoods,
		})
	}

	return
}