crazy_fox_backend_api/service/act_super_collect.go

package service

import (
	"fmt"
	"sort"
	"strconv"
	"strings"

	"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"
)

type actSuperCollect struct{}

func (This *actSuperCollect) handleActShow(actInfo *model.ActConfInfo) (types.JSONText, error) {
	//TODO implement me
	var (
		rewardRepoConfMap map[int64]model.SuperCollectRepoConf
	)

	if err := jsoniter.Unmarshal(actInfo.Reward, &rewardRepoConfMap); err != nil {
		return nil, errors.Wrap(err, actInfo.Type+"的奖励Json解析失败")
	}

	// dept 深层遍历map 转换为切片
	var showConf model.SuperCollectShowConf
	for lvId, rewardRepoConf := range rewardRepoConfMap {
		for spinsId, spinsStage := range rewardRepoConf.Stages {
			for ssGroupId, ssGroupStage := range spinsStage.Stages {

				showConf.RewardInfo = append(showConf.RewardInfo, model.SuperCollectRewardShowConf{
					Id:              Activity.buildLayerOrderId(lvId, spinsId, ssGroupId),
					LvRange:         rewardRepoConf.LvRange,
					SpinsRange:      spinsStage.SpinsRange,
					SsGroup:         ssGroupStage.SsGroup,
					SlotWeightGroup: ssGroupStage.SlotWeightGroup,
					Reward:          utils.MapValues(ssGroupStage.List, true),
				})
			}
		}
	}
	sort.SliceStable(showConf.RewardInfo, func(i, j int) bool { return showConf.RewardInfo[i].Id < showConf.RewardInfo[j].Id })

	if err := jsoniter.Unmarshal(actInfo.ExtraData, &showConf.ExtraData); err != nil {
		return nil, errors.Wrap(err, actInfo.Type+"的奖励Json解析失败")
	}
	if err := jsoniter.Unmarshal(actInfo.RewardConf, &showConf.CollectConf); err != nil {
		return nil, errors.Wrap(err, actInfo.Type+"的奖励Json解析失败")
	}

	return jsoniter.Marshal(showConf)
}

func (This *actSuperCollect) handleActSave(actInfo *model.ActConfInfo) error {
	//TODO implement me
	var (
		actShowConf model.SuperCollectShowConf
		err         error
	)
	if err = jsoniter.Unmarshal(actInfo.ActShowConf, &actShowConf); err != nil {
		return errors.Wrap(err, "保存失败！")
	}

	if actInfo.ExtraData, err = jsoniter.Marshal(actShowConf.ExtraData); err != nil {
		return errors.Wrap(err, "保存失败！")
	}

	if actInfo.RewardConf, err = jsoniter.Marshal(actShowConf.CollectConf); err != nil {
		return errors.Wrap(err, "保存失败！")
	}

	actInfo.Reward, err = This.formatSaveData(actShowConf)
	return err
}

func (This *actSuperCollect) handleActRewardSection(actInfo *model.ActConfInfo, maps ...map[string]any) error {
	//TODO implement me
	var (
		rewardRepoConf map[int64]model.SuperCollectRepoConf
		err            error
		stageKey       string
	)

	if err = jsoniter.Unmarshal(actInfo.Reward, &rewardRepoConf); err != nil {
		return errors.Wrap(err, "保存失败！")
	}

	conditionMap, rewardMap := maps[0], maps[1]
	for lvIdx, lvStage := range rewardRepoConf {
		for spinsIdx, spinsStage := range lvStage.Stages {
			for ssIdx, ssStage := range spinsStage.Stages {
				stageKey = fmt.Sprintf("%v_%v_%v", lvIdx, spinsIdx, ssIdx)
				conditionMap[stageKey] = Activity.buildStageCondition(lvStage.LvRange, spinsStage.SpinsRange, ssStage.SsGroup)
				rewardMap[stageKey] = ssStage.List
			}
		}
	}

	return nil
}

func (This *actSuperCollect) formatSaveData(actShowConf model.SuperCollectShowConf) (types.JSONText, error) {
	var (
		lvIdx       int64
		spinsIdx    int64
		ssIdx       int64
		unique      = uniqid.GetUniqId()
		repoConfMap = map[int64]model.SuperCollectRepoConf{}
		rewardList  map[int64]model.SuperCollectStageReward
	)
	defer uniqid.DelMapByUniqId(unique)
	for _, oneRowInfo := range actShowConf.RewardInfo {
		idxes := uniqid.GetStageIdx(unique, oneRowInfo.LvRange, oneRowInfo.SpinsRange, oneRowInfo.SsGroup)
		lvIdx, spinsIdx, ssIdx = idxes[0], idxes[1], idxes[2]
		rewardList = map[int64]model.SuperCollectStageReward{}
		for stageIdx, rewardRow := range oneRowInfo.Reward {
			rewardList[int64(stageIdx+1)] = rewardRow
		}

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

		if _, Ok := repoConfMap[lvIdx].Stages[spinsIdx]; !Ok {
			repoConfMap[lvIdx].Stages[spinsIdx] = model.SuperCollectSpinsStage{
				oneRowInfo.SpinsRange, map[int64]model.SuperCollectSSGroupStage{},
			}
		}

		if _, Ok := repoConfMap[lvIdx].Stages[spinsIdx].Stages[ssIdx]; !Ok {
			repoConfMap[lvIdx].Stages[spinsIdx].Stages[ssIdx] = model.SuperCollectSSGroupStage{
				oneRowInfo.SsGroup, oneRowInfo.SlotWeightGroup, rewardList,
			}
		}

	}
	return jsoniter.Marshal(repoConfMap)
}

func (This *actSuperCollect) handleActImport(_ *model.ActDetailInfo, excelInfo [][][]string) (types.JSONText, error) {
	//TODO implement me
	var (
		sheetIdx      int64 = 0
		err           error
		stagesMap     []model.ThreeLayer
		slotWeightMap map[int64]int64
		rewardsMap    map[int64][]model.SuperCollectStageReward
		actShowConf   model.SuperCollectShowConf
	)
	if len(excelInfo) < 3 {
		return nil, errors.New("导入文件异常")
	}
	basicConfSheet := excelInfo[sheetIdx]
	sheetIdx++
	stageMappingSheet := excelInfo[sheetIdx]
	sheetIdx++
	stageRewardSheet := excelInfo[sheetIdx]
	sheetIdx++

	if actShowConf.CollectConf, err = This.formatCollectConfSheet(basicConfSheet); err != nil {
		return nil, err
	}

	if actShowConf.ExtraData, err = This.formatExtraDataSheet(basicConfSheet); err != nil {
		return nil, err
	}

	if stagesMap, err = Activity.parseThreeLayerConf(stageMappingSheet); err != nil {
		return nil, errors.WithStack(err)
	}

	if slotWeightMap, err = Activity.parseSlotWeightConf(stageMappingSheet); err != nil {
		return nil, errors.WithStack(err)
	}

	if rewardsMap, err = This.parseRewardInfo(stageRewardSheet); err != nil {
		return nil, errors.WithStack(err)
	}

	if actShowConf.RewardInfo, err = This.matchStageRewardsConf(stagesMap, rewardsMap, slotWeightMap); err != nil {
		return nil, errors.WithStack(err)
	}

	return jsoniter.Marshal(actShowConf)
}
func (This *actSuperCollect) formatCollectConfSheet(collectConfSheet [][]string) (model.SuperCollectCollectConf, error) {
	//TODO implement me
	var (
		err        error
		rewardConf = model.SuperCollectCollectConf{}
	)
	for _, lineItem := range collectConfSheet {
		if len(lineItem) < 2 {
			continue
		}
		switch lineItem[0] {
		case config.CollectTypeOptionImportText:
			rewardConf.GroupId, err = This.getCollectGroupIdByImportText(lineItem[1])
		case config.CollectTypeAttackSuccessImportText:
			rewardConf.AttackSuccess, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeAttackBreakImportText:
			rewardConf.AttackBreak, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeStealSuccessImportText:
			rewardConf.StealSuccess, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeStealBreakImportText:
			rewardConf.StealBreak, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeOneCollectImportText:
			rewardConf.OneHit, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeTwoCollectImportText:
			rewardConf.TwoHit, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeThreeCollectImportText:
			rewardConf.ThreeHit, err = This.getCollectNum(lineItem[1])
		case config.CollectTypeThreeHitImportText:
			rewardConf.ThreeHit, err = This.getCollectNum(lineItem[1])
		}
		if err != nil {
			return rewardConf, err
		}
	}
	return rewardConf, nil
}
func (This *actSuperCollect) getCollectGroupIdByImportText(collectTypeText string) (int64, error) {
	switch collectTypeText {
	case config.CollectTypeOptionNormalImportText:
		return config.CollectTypeOptionNormal, nil
	case config.CollectTypeOptionSpecialImportText:
		return config.CollectTypeOptionSpecial, nil
	case config.CollectTypeOptionSpecialStealImportText:
		return config.CollectTypeOptionSpecialSteal, nil
	case config.CollectTypeOptionSpecialAttackImportText:
		return config.CollectTypeOptionSpecialAttack, nil
	case config.CollectTypeOptionStealImportText:
		return config.CollectTypeOptionSteal, nil
	case config.CollectTypeOptionAttackImportText:
		return config.CollectTypeOptionAttack, nil
	}
	return 0, errors.New("不支持的收集类型：" + collectTypeText)
}
func (This *actSuperCollect) getCollectNum(collectNumText string) (int64, error) {
	collectNum, err := strconv.Atoi(collectNumText)
	return int64(collectNum), err
}

func (This *actSuperCollect) formatExtraDataSheet(extraConfSheet [][]string) (model.SuperCollectExtraData, error) {
	//TODO implement me
	var (
		extraData = model.SuperCollectExtraData{}
	)
	for _, lineItem := range extraConfSheet {
		if len(lineItem) < 2 {
			continue
		}
		switch lineItem[0] {
		case config.SuperCollectShowSpineSwitchImportText:
			extraData.IsShowSpine = This.parseYesOrNo(lineItem[1])
		case config.SuperCollectTimeLimitedSwitchImportText:
			extraData.Open = This.parseYesOrNo(lineItem[1])
		case config.SuperCollectTimeLimitedImportText:
			extraData.Ts = This.parseTimeLimtedList(lineItem)
		}
	}
	return extraData, nil
}

func (This *actSuperCollect) parseYesOrNo(text string) int64 {
	switch text {
	case config.YesImportText:
		return 1
	case config.NoImportText:
		return 0
	}
	return 0
}

func (This *actSuperCollect) parseTimeLimtedList(textList []string) []model.SuperCollectCollectTimeLimitConf {
	var time []string
	var tsList = []model.SuperCollectCollectTimeLimitConf{}
	for i := 1; i < len(textList); i++ {
		time = strings.Split(textList[i], " ~ ")
		tsList = append(tsList, model.SuperCollectCollectTimeLimitConf{
			S: time[0],
			E: time[1],
		})
	}
	return tsList
}

func (This *actSuperCollect) parseSlotWeightConf(stageMapSheet [][]string) (map[int64]int64, error) {
	var (
		slotWeightMap       = map[int64]int64{}
		slotWeightGroupText string
		slotWeightGroupId   int64
		idx                 int64
		err                 error
	)
	for i := 1; i < len(stageMapSheet); i++ {
		if len(stageMapSheet[i]) < 7 {
			return nil, errors.New("索引配置异常")
		}
		idx, _ = strconv.ParseInt(stageMapSheet[i][0], 10, 64)
		slotWeightGroupText = stageMapSheet[i][6]
		if slotWeightGroupId, err = Props.ParseSlotWeightGroup(slotWeightGroupText); err != nil {
			return nil, err
		}
		slotWeightMap[idx] = slotWeightGroupId
	}
	return slotWeightMap, nil
}

func (This *actSuperCollect) parseRewardInfo(rewardSheet [][]string) (map[int64][]model.SuperCollectStageReward, error) {
	var (
		rewardsMap        = map[int64][]model.SuperCollectStageReward{}
		rewards           model.SuperCollectStageReward
		err               error
		rewardSheetLength = len(rewardSheet)
		idx               int64
		prize             = make([]model.ExcelPrize, 2)
		prizeTs           = make([]model.ExcelPrize, 2)
		prizeTsFormatter  []model.ActPrize
	)
	for i := 1; i < rewardSheetLength; i++ {
		rewards = model.SuperCollectStageReward{}
		err = utils.DestructAssign(rewardSheet[i], &idx, &rewards.StepNum, &rewards.StageSpins, &prize, &prizeTs)
		if err != nil {
			return nil, errors.Wrap(err, rewardSheet[i][0])
		}
		// 转换奖励格式
		if rewards.Prize, err = Props.MultiParseActPrize(prize); err != nil {
			return nil, errors.WithStack(err)
		}

		if prizeTsFormatter, err = Props.MultiParseActPrize(prizeTs); err != nil {
			return nil, errors.WithStack(err)
		}
		for _, prizeTmp := range prizeTsFormatter {
			prizeTmp.IsTs = 1
			rewards.Prize = append(rewards.Prize, prizeTmp)
		}

		rewardsMap[idx] = append(rewardsMap[idx], rewards)
	}
	return rewardsMap, nil
}

func (This *actSuperCollect) matchStageRewardsConf(stagesMap []model.ThreeLayer, rewardsMap map[int64][]model.SuperCollectStageReward, slotWeightMap map[int64]int64) ([]model.SuperCollectRewardShowConf, error) {
	var (
		rewardsShowConf = make([]model.SuperCollectRewardShowConf, 0, len(stagesMap))
	)
	for _, oneLayer := range stagesMap {
		idx := oneLayer.Id
		rewards, ok := rewardsMap[idx]
		if !ok {
			return nil, errors.New("未配置奖励项")
		}
		slotWeight, ok := slotWeightMap[idx]
		if !ok {
			return nil, errors.New("未配置老虎机权重分组")
		}
		rewardsShowConf = append(rewardsShowConf, model.SuperCollectRewardShowConf{
			Id:              oneLayer.Id,
			LvRange:         oneLayer.LvRange,
			SpinsRange:      oneLayer.SpinsRange,
			SsGroup:         oneLayer.SsGroup,
			SlotWeightGroup: model.SlotWeightGroup{SlotWeightGroup: slotWeight},
			Reward:          rewards,
		})
	}
	return rewardsShowConf, nil
}