crazy_fox_backend_api/service/island.go

package service

import (
	"fmt"
	"strconv"
	"strings"

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

	jsoniter "github.com/json-iterator/go"
	"github.com/pkg/errors"
	"github.com/xuri/excelize/v2"
)

// islandService 岛屿模块服务
type islandService struct{}

func (This *islandService) BasicConf(req model.PageInfo) ([]model.TCoinConfig, int64) {

	return repo.SearchOnePage[model.TCoinConfig](req.Page, req.PageSize, "")
}

func (This *islandService) BasicConfEdit(req []model.TCoinConfig) error {

	if len(req) == 0 {
		return errors.New("配置列表为空")
	}

	if _, err := repo.Upsert(req); err != nil {
		return errors.WithStack(err)
	}

	cacheMap := make(map[string]model.TCoinConfig, len(req))
	for _, island := range req {
		cacheMap[strconv.FormatInt(island.LevelId, 10)] = island
	}

	// 更新缓存
	cache, err := This.buildIslandConfCache(cacheMap)
	if err != nil {
		return errors.WithStack(err)
	}

	repo.HMSetCache(okeys.LevelConf(), cache)

	return nil
}

func (This *islandService) buildIslandConfCache(confMap map[string]model.TCoinConfig) (cacheMap map[string]any, err error) {

	cacheMap = make(map[string]any, len(confMap))
	for s, conf := range confMap {
		one := model.IslandBasicCache{
			IslandBasic: conf.IslandBasic,
			MinMoney:    conf.CoinConfig[0][0],
			MaxMoney:    conf.CoinConfig[4][4],
		}

		one.CoinConfig, err = jsoniter.MarshalToString(conf.CoinConfig)
		if err != nil {
			return cacheMap, errors.WithStack(err)
		}

		one.Reward, err = jsoniter.MarshalToString(conf.Reward)
		if err != nil {
			return cacheMap, errors.WithStack(err)
		}

		for _, int64s := range conf.CoinConfig {
			for _, i3 := range int64s {
				one.SumMoney += i3
			}
		}
		cacheMap[s] = one
	}

	return cacheMap, err
}

func (This *islandService) handleBasicConfImport(excelInfo [][][]string) (err error) {

	if len(excelInfo) < 3 {
		return errors.New("工作表数量不匹配")
	}

	confArr, err := This.ParseSheet1(excelInfo[0])
	if err != nil {
		return errors.Wrap(err, "岛屿关卡多语言配置 工作表解析失败")
	}

	rewardMap, err := This.ParseSheet2(excelInfo[1])
	if err != nil {
		return errors.Wrap(err, "岛屿关卡奖励配置 工作表解析失败")
	}

	coinMap, err := This.ParseSheet3(excelInfo[2])
	if err != nil {
		return errors.Wrap(err, "岛屿关卡建造价格配置 工作表解析失败")
	}

	if err = This.packageConf(&confArr, rewardMap, coinMap); err != nil {
		return errors.Wrap(err, "岛屿关卡配置 拼装失败")
	}

	if err = This.BasicConfEdit(confArr); err != nil {
		return errors.Wrap(err, "岛屿关卡配置 更新失败")
	}

	return err
}

func (This *islandService) ParseSheet1(sheet [][]string) (confArr []model.TCoinConfig, err error) {

	confArr = make([]model.TCoinConfig, 0, len(sheet))
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var one model.TCoinConfig

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

		confArr = append(confArr, one)
	}

	return
}

func (This *islandService) ParseSheet2(sheet [][]string) (rewardMap map[int64][]model.PropPrize, err error) {

	prizes := make([]model.PropPrize, 0, 5)
	rewardMap = make(map[int64][]model.PropPrize, len(sheet))

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

		var (
			id        int64
			rewardArr = make([]model.ExcelPrize, 5)
		)

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

		// 转换奖励格式
		if prizes, err = Props.MultiParsePropPrize(rewardArr); err != nil {
			return rewardMap, errors.WithStack(err)
		}

		rewardMap[id] = prizes
	}

	return rewardMap, err
}

func (This *islandService) ParseSheet3(sheet [][]string) (coinMap map[int64][5][5]int64, err error) {

	var curId int64
	var coin [5][5]int64

	coinMap = make(map[int64][5][5]int64, len(sheet))

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

		var (
			id     int64
			ignore string
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &ignore, &coin[(rowIdx-1)%5]); err != nil {
			return coinMap, errors.WithStack(err)
		}

		if rowIdx%5 == 1 {
			curId = id
		}

		// 等级配置错误
		if id != curId {
			return coinMap, errors.New(fmt.Sprintf("第%d行,等级配置错误", rowIdx+1))
		}
		if rowIdx%5 == 0 {
			coinMap[id] = coin
			coin = [5][5]int64{}
		}
	}

	return coinMap, err
}

func (This *islandService) packageConf(confArr *[]model.TCoinConfig, rewardMap map[int64][]model.PropPrize, coinMap map[int64][5][5]int64) (err error) {

	var Ok bool
	for i := 0; i < len(*confArr); i++ {
		one := &(*confArr)[i]

		if one.Reward, Ok = rewardMap[one.LevelId]; !Ok {
			return errors.New(fmt.Sprintf("等级:%d,未配置奖励项", one.LevelId))
		}
		if one.CoinConfig, Ok = coinMap[one.LevelId]; !Ok {
			return errors.New(fmt.Sprintf("等级:%d,未配置建造价格项", one.LevelId))
		}

		one.PictureId = one.LevelId
		for _, prize := range one.Reward {
			switch prize.PropsId {
			case config.PropCoin:
				one.RewardCoin = prize.Num
			case config.PropSpin:
				one.RewardSpin = prize.Num
			}
		}
	}

	return
}

func (This *islandService) handleBasicConfExport(xlsx *excelize.File, fileName *string) (err error) {

	list := repo.Search[model.TCoinConfig]("")

	// 工作表1
	sheetName := "多语言配置"
	if err = xlsx.SetSheetName("Sheet1", sheetName); err != nil {
		return errors.WithStack(err)
	}

	if err = This.fillSheet1(xlsx, sheetName, list); err != nil {
		return err
	}

	// 工作表2
	sheetName = "奖励配置"
	if _, err = xlsx.NewSheet(sheetName); err != nil {
		return errors.WithStack(err)
	}

	if err = This.fillSheet2(xlsx, sheetName, list); err != nil {
		return err
	}

	// 工作表3
	sheetName = "建造价格配置"
	if _, err = xlsx.NewSheet(sheetName); err != nil {
		return errors.WithStack(err)
	}

	if err = This.fillSheet3(xlsx, sheetName, list); err != nil {
		return err
	}

	*fileName = "岛屿关卡基础配置"

	return err
}

func (This *islandService) fillSheet1(xlsx *excelize.File, sheetName string, list []model.TCoinConfig) (err error) {

	titles := []string{"关卡", "中文", "英文", "繁体", "法语", "德语", "西班牙语", "葡萄牙语", "泰语", "越南语", "挪威语", "印尼语",
		"罗马尼亚语", "马来西亚语", "意大利语", "波兰语"}

	if err = xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	for i, oneInfo := range list {

		rowSlice := utils.Destruct(oneInfo.LevelId, oneInfo.IsLandLang)
		if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", i+2), &rowSlice); err != nil {
			return errors.WithStack(err)
		}
	}

	return err
}

func (This *islandService) fillSheet2(xlsx *excelize.File, sheetName string, list []model.TCoinConfig) (err error) {

	titles := make([]string, 0, 5*3+1)
	titles = append(titles, "关卡")
	for i := 1; i <= 5; i++ {
		titles = append(titles, fmt.Sprintf("奖励%d", i), "是否固定值(非金币奖励均为固定值)", "数值(宝箱等部分奖励数量固定为1)")
	}

	if err = xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	var prizes []model.ExcelPrize
	for i, oneInfo := range list {

		prizes, err = Props.MultiParseExcelPrize(oneInfo.Reward)
		if err != nil {
			return errors.WithStack(err)
		}

		rowSlice := utils.Destruct(oneInfo.LevelId, prizes)
		if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", i+2), &rowSlice); err != nil {
			return errors.WithStack(err)
		}
	}

	return err
}

func (This *islandService) fillSheet3(xlsx *excelize.File, sheetName string, list []model.TCoinConfig) (err error) {

	titles := []string{"关卡ID", "物件", "1级", "2级", "3级", "4级", "5级"}
	if err = xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	buildName := []string{"建筑", "雕像", "风景", "生物", "科技"}

	rowId := 2
	for _, oneInfo := range list {
		for i2, int64s := range oneInfo.CoinConfig {
			rowSlice := []any{oneInfo.LevelId, buildName[i2], int64s[0], int64s[1], int64s[2], int64s[3], int64s[4]}
			if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", rowId), &rowSlice); err != nil {
				return errors.WithStack(err)
			}
			rowId++
		}
	}

	return err
}

func (This *islandService) ThemeConf(req model.PageInfo) ([]model.TMainBgConfig, int64) {

	list, total := repo.SearchOnePage[model.TMainBgConfig](req.Page, req.PageSize, "")
	for i := 0; i < len(list); i++ {
		list[i].Color1 = strings.ToUpper(list[i].Color1)
		list[i].Color2 = strings.ToUpper(list[i].Color2)
	}
	return list, total
}

func (This *islandService) ThemeConfEdit(req []model.TMainBgConfig) error {

	if len(req) == 0 {
		return errors.New("配置列表为空")
	}

	for i := 0; i < len(req); i++ {
		island := &req[i]
		island.Color1 = strings.ToUpper(island.Color1)
		island.Color2 = strings.ToUpper(island.Color2)
	}

	if _, err := repo.Upsert(req); err != nil {
		return errors.WithStack(err)
	}

	if err := This.updateThemeStatic(); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func (This *islandService) updateThemeStatic() (err error) {

	list := repo.Search[model.TMainBgConfig]("")

	if err = Config.SaveJson(list, "MainBgConfig"); err != nil {
		return errors.WithStack(err)
	}

	return
}

func (This *islandService) handleThemeImport(excelInfo [][][]string) (err error) {

	excelData := excelInfo[0]

	mulSpend := make([]model.TMainBgConfig, 0, len(excelData))
	for i := 1; i < len(excelData); i++ {
		var one model.TMainBgConfig
		if err = utils.DestructAssign(excelData[i], &one); err != nil {
			return errors.WithStack(err)
		}

		mulSpend = append(mulSpend, one)
	}

	if err = This.ThemeConfEdit(mulSpend); err != nil {
		return errors.WithStack(err)
	}

	return err
}

func (This *islandService) handleThemeExport(xlsx *excelize.File, fileName *string) (err error) {

	// 工作表1
	sheetName := "配置表"
	if err = xlsx.SetSheetName("Sheet1", sheetName); err != nil {
		return errors.WithStack(err)
	}

	titles := []string{"岛屿ID", "背景1", "背景1云朵色号", "背景2", "背景2云朵色号", "动画", "动画2"}
	if err = xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	list := repo.Search[model.TMainBgConfig]("")

	for i, oneInfo := range list {

		rowSlice := utils.Destruct(oneInfo)
		if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", i+2), &rowSlice); err != nil {
			return errors.WithStack(err)
		}
	}

	*fileName = "岛屿主题配置"

	return err
}

func (This *islandService) MaxLevelReward() (reward model.MaxIslandReward, err error) {

	content, err := Config.GetSystemConf(model.ItemTitle{Item: "Reward", Title: "maxLevel"})
	if err != nil {
		return reward, errors.WithStack(err)
	}

	if err = jsoniter.UnmarshalFromString(content, &reward); err != nil {
		return reward, errors.WithStack(err)
	}

	return
}

func (This *islandService) MaxLevelRewardEdit(req *model.MaxIslandReward) error {
	content, err := jsoniter.MarshalToString(req)
	if err != nil {
		return errors.WithStack(err)
	}

	sysConf := model.TSystemConfig{
		ItemTitle: model.ItemTitle{Item: "Reward", Title: "maxLevel"},
		Content:   content,
		Memo:      "最大关卡奖励",
	}

	if err = Config.UpdateSystemConf(sysConf); err != nil {
		return errors.WithStack(err)
	}

	return nil
}