crazy_fox_backend_api/service/act_crazy_build.go

package service

import (
	"fmt"
	"sort"

	"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 actCrazyBuild struct{}

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

	var rewardConf map[int64]model.CrazyBuildRewardConf
	if err = jsoniter.Unmarshal(confInfo.Reward, &rewardConf); err != nil {
		return json, errors.Wrap(err, "疯狂建造 奖励Json解析失败")
	}

	// 基础配置
	var baseConf model.CrazyBuildBasicConf
	if err = jsoniter.Unmarshal(confInfo.ExtraData, &baseConf); err != nil {
		return nil, errors.Wrap(err, "疯狂建造 基础配置Json解析失败")
	}

	// 数据转换
	showConf := This.convertIntoShowConf(rewardConf, baseConf)
	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "疯狂建造 奖励序列化失败")
	}

	return
}

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

	var showConf model.CrazyBuildShowConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConf); err != nil {
		return errors.Wrap(err, "疯狂建造 奖励Json解析失败")
	}

	// 数据转换
	var rewardMap map[int64]model.CrazyBuildRewardConf
	if rewardMap, err = This.convertIntoRewardConf(showConf.RewardInfo); err != nil {
		return errors.Wrap(err, "疯狂建造 奖励数据转换失败")
	}

	if confInfo.Reward, err = jsoniter.Marshal(rewardMap); err != nil {
		return errors.Wrap(err, "疯狂建造 奖励数据序列化失败")
	}

	// 收集配置
	if confInfo.ExtraData, err = jsoniter.Marshal(showConf.BasicConf); err != nil {
		return errors.Wrap(err, "疯狂建造 收集配置数据序列化失败")
	}

	return
}

// 分层数据处理
func (This *actCrazyBuild) handleActRewardSection(confInfo *model.ActConfInfo, maps ...map[string]any) error {
	var rewardRepoConfMap map[int64]model.CrazyBuildRewardConf
	if err := jsoniter.Unmarshal(confInfo.Reward, &rewardRepoConfMap); err != nil {
		return errors.Wrap(err, "疯狂建造奖励解析失败")
	}

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

		conditionMap[stageKey] = Activity.buildStageCondition(item1.SsGroup)
		rewardMap[stageKey] = item1.Reward
	}

	return nil
}

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

	var showConf model.CrazyBuildShowConf
	if showConf, err = This.sheetResolver(excelInfo); err != nil {
		return json, errors.Wrap(err, "疯狂建造 工作表解析失败")
	}

	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "疯狂建造 配置序列化失败")
	}

	return
}

func (This *actCrazyBuild) convertIntoShowConf(rewardConf map[int64]model.CrazyBuildRewardConf, baseConf model.CrazyBuildBasicConf) (showConf model.CrazyBuildShowConf) {

	for ssGroupId, ssGroupStage := range rewardConf {
		showRewards := make([]model.CrazyBuildShowReward, 0, len(ssGroupStage.Reward.BasicReward))
		for lv, oneReward := range ssGroupStage.Reward.BasicReward {
			showRewards = append(showRewards, model.CrazyBuildShowReward{
				UserLevel:  lv,
				BasicPrize: oneReward.Prize,
				FinalPrize: ssGroupStage.Reward.FinalReward[lv].Prize,
			})
		}
		sort.SliceStable(showRewards, func(i, j int) bool { return showRewards[i].UserLevel < showRewards[j].UserLevel })

		showConf.RewardInfo = append(showConf.RewardInfo, model.CrazyBuildRewardShowConf{
			OneLayerSsGroup: model.OneLayerSsGroup{
				Id:      Activity.buildLayerOrderId(ssGroupId),
				SsGroup: ssGroupStage.SsGroup,
			},
			Reward: This.makeShowRangeRewardArr(showRewards),
		})
	}
	sort.SliceStable(showConf.RewardInfo, func(i, j int) bool { return showConf.RewardInfo[i].Id < showConf.RewardInfo[j].Id })

	showConf.BasicConf = baseConf

	return
}

func (This *actCrazyBuild) convertIntoRewardConf(rewardShowConfArr []model.CrazyBuildRewardShowConf) (map[int64]model.CrazyBuildRewardConf, error) {

	var (
		rewardRepoConfMap = map[int64]model.CrazyBuildRewardConf{}
		unique            = uniqid.GetUniqId()
	)

	defer uniqid.DelMapByUniqId(unique)
	for i := 0; i < len(rewardShowConfArr); i++ {
		oneRowInfo := rewardShowConfArr[i]
		oneRowRewardLen := len(oneRowInfo.Reward)

		ssIdx := uniqid.GetStageIdx(unique, oneRowInfo.SsGroup)[0]

		rewardStage := model.CrazyBuildReward{
			BasicReward: map[int64]model.CrazyBuildStageReward{},
			FinalReward: map[int64]model.CrazyBuildStageReward{},
		}

		// 构建奖励Map
		rewardStage.BasicReward = make(map[int64]model.CrazyBuildStageReward, oneRowInfo.Reward[oneRowRewardLen-1].LvEnd)
		rewardStage.FinalReward = make(map[int64]model.CrazyBuildStageReward, oneRowInfo.Reward[oneRowRewardLen-1].LvEnd)
		for j := 0; j < oneRowRewardLen; j++ {
			oneReward := oneRowInfo.Reward[j]
			for lv := oneReward.LvStart; lv <= oneReward.LvEnd; lv++ {
				rewardStage.BasicReward[lv] = model.CrazyBuildStageReward{
					UserLevel: lv,
					Prize:     oneReward.BasicPrize,
				}
				rewardStage.FinalReward[lv] = model.CrazyBuildStageReward{
					UserLevel: lv,
					Prize:     oneReward.FinalPrize,
				}
			}
		}

		// 数数分组
		if _, Ok := rewardRepoConfMap[ssIdx]; !Ok {
			rewardRepoConfMap[ssIdx] = model.CrazyBuildRewardConf{
				SsGroup: oneRowInfo.SsGroup,
				Reward:  rewardStage,
			}
		}
	}

	return rewardRepoConfMap, nil
}

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

	sheet1Array, sheet2Array, sheet3Array := excelInfo[0], excelInfo[1], excelInfo[2]

	// 解析基础配置
	showConf, err = This.parseBaseSheet(sheet1Array)

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

	// 解析奖励配置项
	var rewardMap map[int64][]model.CrazyBuildShowRangeReward
	if rewardMap, err = This.parseRewardSheet(sheet3Array); err != nil {
		return showConf, errors.WithStack(err)
	}

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

	return
}

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

	var err error
	stageRewardMap := map[int64][]model.CrazyBuildShowRangeReward{}

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

		var (
			id             int64
			one            model.CrazyBuildShowRangeReward
			basicRewardArr = make([]model.ExcelPrize, 3)
			finalRewardArr = make([]model.ExcelPrize, 3)
		)

		// 解析行配置
		if err = utils.DestructAssign(rewardsSheet[rowIdx], &id, &one.LvRange, &basicRewardArr, &finalRewardArr); err != nil {
			return nil, errors.WithStack(err)
		}

		// 转换奖励格式
		if one.BasicPrize, err = Props.MultiParseActPrize(basicRewardArr); err != nil {
			return nil, errors.WithStack(err)
		}

		// 转换奖励格式
		if one.FinalPrize, err = Props.MultiParseActPrize(finalRewardArr); err != nil {
			return nil, errors.WithStack(err)
		}

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

	return stageRewardMap, nil
}

func (This *actCrazyBuild) packageShowConf(showConf *model.CrazyBuildShowConf, layers []model.OneLayerSsGroup, rewardMap map[int64][]model.CrazyBuildShowRangeReward) (err error) {

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

		rewardConfArr = append(rewardConfArr, model.CrazyBuildRewardShowConf{
			OneLayerSsGroup: layer,
			Reward:          reward,
		})
	}

	showConf.RewardInfo = rewardConfArr

	return
}

func (This *actCrazyBuild) makeShowRangeRewardArr(rewards []model.CrazyBuildShowReward) []model.CrazyBuildShowRangeReward {
	lens := len(rewards)
	if lens == 0 {
		return []model.CrazyBuildShowRangeReward{}
	}
	showRangeRewards := make([]model.CrazyBuildShowRangeReward, 0, lens/2)

	// 初始化

	lvRange := model.LvRange{
		LvStart: rewards[0].UserLevel,
		LvEnd:   rewards[0].UserLevel,
	}

	for i := 1; i < lens; i++ {
		if Props.PropsStrictEqual(rewards[i].FinalPrize, rewards[i-1].FinalPrize) && Props.PropsStrictEqual(rewards[i].BasicPrize, rewards[i-1].BasicPrize) {
			lvRange.LvEnd = rewards[i].UserLevel
		} else {
			showRangeRewards = append(showRangeRewards, model.CrazyBuildShowRangeReward{
				LvRange:    lvRange,
				BasicPrize: rewards[i-1].BasicPrize,
				FinalPrize: rewards[i-1].FinalPrize,
			})

			lvRange = model.LvRange{
				LvStart: rewards[i].UserLevel,
				LvEnd:   rewards[i].UserLevel,
			}
		}
	}

	showRangeRewards = append(showRangeRewards, model.CrazyBuildShowRangeReward{
		LvRange:    lvRange,
		BasicPrize: rewards[lens-1].BasicPrize,
		FinalPrize: rewards[lens-1].FinalPrize,
	})

	return showRangeRewards
}

func (This *actCrazyBuild) parseBaseSheet(sheet [][]string) (showConf model.CrazyBuildShowConf, err error) {

	for i := 0; i < len(sheet); i++ {
		if len(sheet[i]) == 0 || sheet[i][0] != "活动层数" {
			continue
		}

		var ignore string
		if err = utils.DestructAssign(sheet[i], &ignore, &showConf.BasicConf.Layer); err != nil {
			return showConf, errors.WithStack(err)
		}
	}

	return
}