package base

import (
	"encoding/json"
	"fmt"
	"math"
	"strconv"
	"strings"
	"sync"
	"time"

	"mongo.games.com/goserver/core/basic"
	"mongo.games.com/goserver/core/task"

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/protocol/server"
	"mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/srvdata"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/module"
)

const (
	CoinPoolStatus_Normal  = iota //库存下限 < 库存值 < 库存上限
	CoinPoolStatus_Low            //库存值 < 库存下限
	CoinPoolStatus_High           //库存上限 < 库存值 < 库存上限+偏移量
	CoinPoolStatus_TooHigh        //库存>库存上限+偏移量
)

var CoinPoolMgr = &CoinPoolManager{
	CoinPool:        new(sync.Map),
	ProfitPool:      new(sync.Map),
	CoinPoolSetting: make(map[string]*webapi.CoinPoolSetting),
	curRunTime:      make(map[string]int64),
	publicPond:      new(sync.Map),
	bossPond:        new(sync.Map),
}

func GetCoinPoolMgr() *CoinPoolManager {
	return CoinPoolMgr
}

const CoinPoolKeyToken = "-"
const CoinPoolKeyTokenGroup = "+"

type CoinPoolListener interface {
	OnSettingUpdate(oldSetting, newSetting *webapi.CoinPoolSetting)
}

type CoinPoolManager struct {
	//调控池
	CoinPoolDBKey string
	CoinPool      *sync.Map
	//收益池
	ProfitPoolDBKey string
	ProfitPool      *sync.Map

	dirty bool

	// 水池配置
	CoinPoolSetting map[string]*webapi.CoinPoolSetting //初始化值需要配置数据表DB_GameCoinPool
	// 重置水池的时间，水池索引：时间戳
	curRunTime map[string]int64

	listener []CoinPoolListener // 捕鱼

	publicPond *sync.Map //公共池
	bossPond   *sync.Map //BOSS池
}

func (this *CoinPoolManager) RegisterListener(l CoinPoolListener) {
	this.listener = append(this.listener, l)
}

func (this *CoinPoolManager) GenKey(gameFreeId int32, platform string, groupId int32) string {
	var key string
	if groupId != 0 {
		key = fmt.Sprintf("%v%v%v", gameFreeId, CoinPoolKeyTokenGroup, groupId)
	} else {
		key = fmt.Sprintf("%v%v%v", gameFreeId, CoinPoolKeyToken, platform)
	}
	return key
}

func (this *CoinPoolManager) SplitKey(key string) (gameFreeId, groupId int32, platform string, ok bool) {
	if strings.Contains(key, CoinPoolKeyToken) {
		datas := strings.Split(key, CoinPoolKeyToken)
		if len(datas) >= 2 {
			id, err := strconv.Atoi(datas[0])
			if err == nil {
				gameFreeId = int32(id)
			}
			platform = datas[1]
			ok = true
			return
		}
	} else {
		datas := strings.Split(key, CoinPoolKeyTokenGroup)
		if len(datas) >= 2 {
			id, err := strconv.Atoi(datas[0])
			if err == nil {
				gameFreeId = int32(id)
			}
			id, err = strconv.Atoi(datas[1])
			if err == nil {
				groupId = int32(id)
			}
			ok = true
			return
		}
	}
	return
}

// AddProfitPool 增加收益池
func (this *CoinPoolManager) AddProfitPool(key string, coin int64) bool {
	if this.getCoinPoolSetting(key).GetSwitch() == 1 {
		return false
	}

	poolValue, ok := this.ProfitPool.Load(key)
	if !ok {
		this.ProfitPool.Store(key, coin)
		this.dirty = true
		return true
	}
	poolCoin, ok := poolValue.(int64)
	if !ok {
		return false
	}

	this.ProfitPool.Store(key, poolCoin+coin)
	this.dirty = true
	return true
}

// GetProfitPoolCoin 获取收益池水位
func (this *CoinPoolManager) GetProfitPoolCoin(gameFreeId int32, platform string, groupId int32) int64 {
	key := this.GenKey(gameFreeId, platform, groupId)
	poolValue, ok := this.ProfitPool.Load(key)
	if !ok {
		return 0
	}
	poolCoin, ok := poolValue.(int64)
	if !ok {
		logger.Logger.Errorf("Error type convert in coinpoolmanager GetProfitPoolCoin:%v-%v", key, poolValue)
		return 0
	}
	return poolCoin
}

// GetProfitRate 获取营收比例
func (this *CoinPoolManager) GetProfitRate(setting *webapi.CoinPoolSetting) int32 {
	if setting == nil {
		return 0
	}

	// 营收比例
	rate := setting.GetProfitRate()
	if rate != 0 {
		return rate
	}
	return 0
}

// 获取调控池水位
func (this *CoinPoolManager) getCoinPoolCoin(key string) int64 {
	poolValue, ok := this.CoinPool.Load(key)
	if !ok {
		return 0
	}
	poolCoin, ok := poolValue.(int64)
	if !ok {
		logger.Logger.Errorf("Error type convert in coinpoolmanager GetCoin:%v-%v", key, poolValue)
		return 0
	}
	return poolCoin
}

// 减少调控池水位
// 返回当前水位
func (this *CoinPoolManager) popCoin(key string, coin int64) (bool, int64) {
	if this.getCoinPoolSetting(key).GetSwitch() == 1 {
		return false, 0
	}

	poolValue, ok := this.CoinPool.Load(key)
	if !ok {
		return false, 0
	}
	poolCoin, ok := poolValue.(int64)
	if !ok {
		logger.Logger.Errorf("Error type convert in coinpoolmanager popcoin:%v-%v", key, poolValue)
		return false, 0
	}

	//if poolCoin < coin {
	//	return false
	//}

	curValue := poolCoin - coin
	if curValue < -99999999 {
		curValue = -99999999
	}

	this.CoinPool.Store(key, curValue)
	this.dirty = true
	logger.Logger.Infof("$$$$$$$$金币池 %v 取出 %v 金币，现有金币 %v.$$$$$$$$", key, coin, curValue)
	return true, curValue
}

// 增加调控池水位
// 返回当前水位
func (this *CoinPoolManager) pushCoin(key string, coin int64) int64 {
	if this.getCoinPoolSetting(key).GetSwitch() == 1 {
		return 0
	}

	poolValue, ok := this.CoinPool.Load(key)
	if !ok {
		this.CoinPool.Store(key, coin)
		this.dirty = true
		logger.Logger.Infof("$$$$$$$$金币池 %v 放入 %v 金币，现有金币 %v.$$$$$$$$", key, coin, coin)
		return coin
	}
	poolCoin, ok := poolValue.(int64)
	if !ok {
		logger.Logger.Errorf("Coin pool push error type value:%v-%v", key, poolValue)
		return 0
	}
	poolCoin += coin
	this.CoinPool.Store(key, poolCoin)
	this.dirty = true
	logger.Logger.Infof("$$$$$$$$金币池 %v 放入 %v 金币，现有金币 %v.$$$$$$$$", key, coin, poolCoin)
	return poolCoin
}

// PopCoin 减少调控池水位
func (this *CoinPoolManager) PopCoin(gameFreeId, groupId int32, platform string, coin int64) bool {
	if coin == 0 {
		return true
	}

	key := this.GenKey(gameFreeId, platform, groupId)
	poolVal := coin
	if coin < 0 { //负值为收益
		setting := this.getCoinPoolSetting(key)
		if setting != nil && setting.GetSwitch() == 0 {
			rate := this.GetProfitRate(setting)
			if rate != 0 { //负值也生效???
				profit := coin * int64(rate) / 1000
				this.AddProfitPool(key, -profit)
				poolVal = coin - profit
			}
		}
	}
	ok, _ := this.popCoin(key, poolVal)
	if ok {
		dbGameFree := srvdata.PBDB_GameFreeMgr.GetData(gameFreeId)
		if dbGameFree != nil && dbGameFree.GetSceneType() != -1 { //非试玩场
			//保存数据
			//this.ReportCoinPoolRecEvent(gameFreeId, groupId, platform, -coin, curPoolVal, false)
			setting := this.GetCoinPoolSetting(platform, gameFreeId, groupId)
			if setting != nil {
				poolValue, ok := this.CoinPool.Load(key)
				if ok {
					poolCoin, ok := poolValue.(int64)
					if ok {
						if int64(setting.GetLowerLimit()) > poolCoin {
							WarningCoinPool(Warning_CoinPoolLow, gameFreeId)
						}

						if poolCoin < 0 {
							WarningCoinPool(Warning_CoinPoolZero, gameFreeId)
						}
					}
				}
			}
		}
		return true
	}
	return false
}

// PushCoin 增加调控池水位
func (this *CoinPoolManager) PushCoin(gameFreeId, groupId int32, platform string, coin int64) {
	if coin == 0 {
		return
	}
	key := this.GenKey(gameFreeId, platform, groupId)
	poolVal := coin
	if coin > 0 { //处理收益池
		setting := this.getCoinPoolSetting(key)
		if setting != nil && setting.GetSwitch() == 0 {
			rate := this.GetProfitRate(setting)
			if rate != 0 { //负值也生效???
				profit := coin * int64(rate) / 1000
				this.AddProfitPool(key, profit)
				poolVal = coin - profit
			}
		}
	}

	this.pushCoin(key, poolVal)
	return
}

// GetCoin 获取调控池水位
func (this *CoinPoolManager) GetCoin(gameFreeId int32, platform string, groupId int32) int64 {
	key := this.GenKey(gameFreeId, platform, groupId)
	return this.getCoinPoolCoin(key)
}

// UpdateCoinPoolSetting 更新或添加水池配置
// worldsrv创建房间时发送，或后台修改水池后worldsrv发送给gamesrv
func (this *CoinPoolManager) UpdateCoinPoolSetting(setting *webapi.CoinPoolSetting) {
	if setting != nil {
		key := this.GenKey(setting.GetGameFreeId(), setting.GetPlatform(), setting.GetGroupId())
		// ResetTime
		if setting.GetResetTime() != 0 {
			runTime := time.Now().Unix() + setting.GetResetTime()
			this.curRunTime[key] = runTime
		}

		old, _ := this.CoinPoolSetting[key]
		this.CoinPoolSetting[key] = setting
		for _, v := range this.listener {
			v.OnSettingUpdate(old, setting)
		}

		// Switch
		if old.GetSwitch() != setting.GetSwitch() {

		}

		// 调控池初始化
		initValue := setting.GetInitValue()
		if initValue != 0 { //初始化水池
			_, ok := this.CoinPool.Load(key)
			if !ok {
				this.pushCoin(key, int64(initValue))
			}
		}
	}
}

// ResetCoinPool 水位重置
// 后台请求worldsrv,worldsrv发送给gamesrv
func (this *CoinPoolManager) ResetCoinPool(wgRcp *server.WGResetCoinPool) {
	if wgRcp != nil {
		key := this.GenKey(wgRcp.GetGameFreeId(), wgRcp.GetPlatform(), wgRcp.GetGroupId())
		if setting, exist := this.CoinPoolSetting[key]; exist {
			switch wgRcp.GetPoolType() {
			case 1: //水池
				value := int64(wgRcp.GetValue())
				if value == -1 {
					initValue := setting.GetInitValue()
					if initValue != 0 { //初始化水池
						value = int64(initValue)
					}
				}
				this.CoinPool.Store(key, value)
				logger.Logger.Infof("$$$$$$$$金币池 %v 重置金币 %v.$$$$$$$$", key, value)
			case 2: //营收池
				value := int64(wgRcp.GetValue())
				if value == -1 {
					value = 0
				}
				this.ProfitPool.Store(key, value)
				logger.Logger.Infof("$$$$$$$$营收池 %v 重置金币 %v.$$$$$$$$", key, value)
			case 3: //水池&营收池
				value := int64(wgRcp.GetValue())
				if value == -1 {
					initValue := setting.GetInitValue()
					if initValue != 0 { //初始化水池
						value = int64(initValue)
					}
				}
				this.CoinPool.Store(key, value)
				logger.Logger.Infof("$$$$$$$$金币池 %v 重置金币 %v.$$$$$$$$", key, value)

				value = int64(wgRcp.GetValue())
				if value == -1 {
					value = 0
				}
				this.ProfitPool.Store(key, value)
				logger.Logger.Infof("$$$$$$$$营收池 %v 重置金币 %v.$$$$$$$$", key, value)
			}
		}
	}
}

func (this *CoinPoolManager) getCoinPoolSetting(key string) *webapi.CoinPoolSetting {
	if setting, exist := this.CoinPoolSetting[key]; exist {
		return setting
	}
	return nil
}

// GetCoinPoolSetting 获取水池配置
func (this *CoinPoolManager) GetCoinPoolSetting(platform string, gamefreeid, groupId int32) *webapi.CoinPoolSetting {
	key := this.GenKey(gamefreeid, platform, groupId)
	return this.getCoinPoolSetting(key)
}

// GetCoinPoolSettingByGame 获取水池配置
func (this *CoinPoolManager) GetCoinPoolSettingByGame(platform string, gameId, gameMode, groupId int32) (settings []*webapi.CoinPoolSetting) {
	ids, _ := srvdata.DataMgr.GetGameFreeIds(gameId, gameMode)
	for _, id := range ids {
		setting := this.GetCoinPoolSetting(platform, id, groupId)
		if setting != nil {
			s := &webapi.CoinPoolSetting{
				Platform:     setting.GetPlatform(),
				GameFreeId:   setting.GetGameFreeId(),
				ServerId:     setting.GetServerId(),
				GroupId:      setting.GetGroupId(),
				InitValue:    setting.GetInitValue(),
				LowerLimit:   setting.GetLowerLimit(),
				UpperLimit:   setting.GetUpperLimit(),
				QuDu:         setting.GetQuDu(),
				UpperOdds:    setting.GetUpperOdds(),
				UpperOddsMax: setting.GetUpperOddsMax(),
				LowerOdds:    setting.GetLowerOdds(),
				LowerOddsMax: setting.GetLowerOddsMax(),
				ProfitRate:   setting.GetProfitRate(),

				ResetTime: setting.GetResetTime(),
				Switch:    setting.GetSwitch(),

				CoinValue:  this.GetCoin(id, platform, groupId),           // 当前水位
				ProfitPool: this.GetProfitPoolCoin(id, platform, groupId), // 收益池水位
			}
			settings = append(settings, s)
		}
	}
	return
}

func (this *CoinPoolManager) GetCoinPoolOdds(platform string, gamefreeid, groupId int32) int32 {
	var coin int64
	var odds int32
	key := this.GenKey(gamefreeid, platform, groupId)
	setting := this.getCoinPoolSetting(key)
	if setting != nil {
		coin = this.getCoinPoolCoin(key)
		if coin > setting.GetUpperLimit() {
			v := common.SliceMinValue([]int{800, int(float64(coin-setting.GetUpperLimit())/float64(setting.GetQuDu())*
				float64(setting.GetUpperOddsMax()-setting.GetUpperOdds()) + float64(setting.GetUpperOdds()))})
			odds = int32(common.SliceMaxValue([]int{100, v}))
		} else if coin < setting.GetLowerLimit() {
			v := common.SliceMaxValue([]int{-800, int(float64(coin-setting.GetLowerLimit())/float64(setting.GetQuDu())*
				float64(setting.GetLowerOdds()-setting.GetLowerOddsMax()) + float64(setting.GetLowerOdds()))})
			odds = int32(common.SliceMinValue([]int{-100, v}))
		}
	}
	logger.Logger.Tracef("TienLenSceneData 场次水池调控 platform:%v gamefreeid:%v groupId:%v Coin:%v, config:%v 概率:%v",
		platform, gamefreeid, groupId, coin, setting, odds)
	return odds
}

// //////////////////////////////////////////////////////////////////
// / Module Implement [beg]
// //////////////////////////////////////////////////////////////////
func (this *CoinPoolManager) ModuleName() string {
	return "CoinPoolManager"
}

func (this *CoinPoolManager) Init() {
	// 调控池
	this.CoinPoolDBKey = fmt.Sprintf("CoinPoolManager_Srv%v", common.GetSelfSrvId())
	data := model.GetStrKVGameData(this.CoinPoolDBKey)
	coinPool := make(map[string]int64)
	err := json.Unmarshal([]byte(data), &coinPool)
	if err == nil {
		for key, value := range coinPool {
			this.CoinPool.Store(key, value)
		}
	} else {
		logger.Logger.Error("Unmarshal coin pool error:", err)
	}
	// 收益池
	this.ProfitPoolDBKey = fmt.Sprintf("ProfitPoolManager_Srv%v", common.GetSelfSrvId())
	data = model.GetStrKVGameData(this.ProfitPoolDBKey)
	profitPool := make(map[string]int64)
	err = json.Unmarshal([]byte(data), &profitPool)
	if err == nil {
		for key, value := range profitPool {
			this.ProfitPool.Store(key, value)
		}
	} else {
		logger.Logger.Error("Unmarshal profit pool error:", err)
	}
}

func (this *CoinPoolManager) Update() {
	if this.dirty {
		this.dirty = false
		this.Save(true)
	}

}

func (this *CoinPoolManager) Shutdown() {
	this.Save(false)
	module.UnregisteModule(this)
}

func (this *CoinPoolManager) Save(asyn bool) {
	// 调控池
	coinPool := make(map[string]int64)
	this.CoinPool.Range(func(key, value interface{}) bool {
		coinPool[key.(string)] = value.(int64)
		return true
	})
	buff, err := json.Marshal(coinPool)
	if err == nil {
		if asyn {
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.UptStrKVGameData(this.CoinPoolDBKey, string(buff))
			}), nil, "UptStrKVGameData").Start()
		} else {
			model.UptStrKVGameData(this.CoinPoolDBKey, string(buff))
		}
	} else {
		logger.Logger.Error("Marshal coin pool error:", err)
	}
	// 收益池
	profitPool := make(map[string]int64)
	this.ProfitPool.Range(func(key, value interface{}) bool {
		profitPool[key.(string)] = value.(int64)
		return true
	})
	buffProfit, err := json.Marshal(profitPool)
	if err == nil {
		if asyn {
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.UptStrKVGameData(this.ProfitPoolDBKey, string(buffProfit))
			}), nil, "UptStrKVGameData").Start()
		} else {
			model.UptStrKVGameData(this.ProfitPoolDBKey, string(buffProfit))
		}
	} else {
		logger.Logger.Error("Marshal profit pool error:", err)
	}
}

func (this *CoinPoolManager) OnMiniTimer() {

}

func (this *CoinPoolManager) OnHourTimer() {

}

func (this *CoinPoolManager) OnDayTimer() {
	logger.Logger.Info("(this *CoinPoolManager) OnDayTimer")
}

func (this *CoinPoolManager) OnWeekTimer() {
	logger.Logger.Info("(this *CoinPoolManager) OnWeekTimer")
}

func (this *CoinPoolManager) OnMonthTimer() {
	logger.Logger.Info("(this *CoinPoolManager) OnMonthTimer")
	// 每月1号清空营收池
	//this.ClearProfitPool()
}

func (this *CoinPoolManager) GetTax() float64 {
	return 0
}
func (this *CoinPoolManager) SetTax(tax float64) {

}

func init() {
	module.RegisteModule(CoinPoolMgr, time.Minute, 0)
	CoinPoolMgr.RegisterListener(new(CoinPoolFishListener))
}

// GetCoinPoolStatesByPlatform 获取水池状态
func (this *CoinPoolManager) GetCoinPoolStatesByPlatform(platform string, games []*common.GamesIndex) (info map[int32]*common.CoinPoolStatesInfo) {
	info = make(map[int32]*common.CoinPoolStatesInfo)
	for _, g := range games {
		gameId := srvdata.PBDB_GameFreeMgr.GetData(g.GameFreeId).GetGameId()
		key := this.GenKey(g.GameFreeId, platform, g.GroupId)
		pool := this.CoinPoolSetting[key]
		if pool != nil {
			//在当前水池找到了
			state, _ := this.GetCoinPoolStatus(platform, g.GameFreeId, pool.GetGroupId())
			nowsate := int32(1)
			switch state {
			case CoinPoolStatus_Normal:
				nowsate = 1
			case CoinPoolStatus_Low:
				nowsate = 2
			case CoinPoolStatus_High:
				nowsate = 3
			case CoinPoolStatus_TooHigh:
				nowsate = 4
			}
			//当前水池的值
			nowpool := &common.CoinPoolStatesInfo{}
			nowpool.GameId = gameId
			nowpool.GameFreeId = g.GameFreeId
			nowpool.CoinValue = int32(this.GetCoin(g.GameFreeId, platform, g.GroupId))
			nowpool.States = nowsate
			info[g.GameFreeId] = nowpool
		} else {
			//在当前水池没有找到并且已经开启的游戏 给默认值
			//def := srvdata.PBDB_GameCoinPoolMgr.GetData(g.GameFreeId)
			nowpool := &common.CoinPoolStatesInfo{}
			nowpool.GameId = gameId
			nowpool.GameFreeId = g.GameFreeId
			nowpool.States = 1
			info[g.GameFreeId] = nowpool
		}
	}
	return
}

func (this *CoinPoolManager) pushCoinNovice(key string, coin int64) {
}

func (this *CoinPoolManager) popCoinNovice(key string, coin int64) {

}

// PushCoinNovice 增加新手池水位
func (this *CoinPoolManager) PushCoinNovice(gameFreeId, groupId int32, platform string, coin int64) {
	if coin == 0 {
		return
	}
	key := this.GenKey(gameFreeId, platform, groupId)
	this.pushCoinNovice(key, coin)
}

// PopCoinNovice 减少新手池水位
func (this *CoinPoolManager) PopCoinNovice(gameFreeId, groupId int32, platform string, coin int64) {
}

// GetNoviceCoin 获取新手池水位
func (this *CoinPoolManager) GetNoviceCoin(gameFreeId int32, platform string, groupId int32) int64 {
	return 0
}

// IsMaxOutHaveEnough 判定是否满足出分,out 为负值是出分，正值为收分
func (this *CoinPoolManager) IsMaxOutHaveEnough(platform string, gameFreeId int32, groupId int32, out int64) bool {
	return false
}

// GetCoinPoolCtx 获取水池状态
func (this *CoinPoolManager) GetCoinPoolCtx(platform string, gamefreeid, groupId int32) model.CoinPoolCtx {
	setting := this.GetCoinPoolSetting(platform, gamefreeid, groupId)
	if setting == nil {
		return model.CoinPoolCtx{}
	}
	curCoin := this.GetCoin(gamefreeid, platform, groupId)
	state := CoinPoolStatus_Normal
	//switch {
	//case curCoin < int64(setting.GetLowerLimit()):
	//	state = CoinPoolStatus_Low
	//case curCoin > int64(setting.GetUpperLimit()) && curCoin < int64(setting.GetUpperLimit()+setting.GetUpperOffsetLimit()):
	//	state = CoinPoolStatus_High
	//case curCoin > int64(setting.GetUpperLimit()+setting.GetUpperOffsetLimit()):
	//	state = CoinPoolStatus_TooHigh
	//}
	ctx := model.CoinPoolCtx{CurrValue: int32(curCoin), CurrMode: int32(state)}
	ctx.LowerLimit = setting.GetLowerLimit()
	ctx.UpperLimit = setting.GetUpperLimit()
	return ctx
}

func (this *CoinPoolManager) getCoinPoolStatus(platform string, gamefreeid, groupId int32, value int64) (int, int) {
	curCoin := this.GetCoin(gamefreeid, platform, groupId)
	if value < 0 {
		curCoin += value
	}
	setting := this.GetCoinPoolSetting(platform, gamefreeid, groupId)
	if setting == nil {
		return CoinPoolStatus_Normal, 10000
	}
	return CoinPoolStatus_Normal, 10000
}

// GetCoinPoolStatus 获取水池水位状态
func (this *CoinPoolManager) GetCoinPoolStatus(platform string, gamefreeid, groupId int32) (int, int) {
	return this.getCoinPoolStatus(platform, gamefreeid, groupId, 0)
}

// GetCoinPoolStatus2 获取减少水位后的水位状态
// value 减少值，需要带负号
func (this *CoinPoolManager) GetCoinPoolStatus2(platform string, gamefreeid, groupId int32, value int64) (int, int) {
	return this.getCoinPoolStatus(platform, gamefreeid, groupId, value)
}

// 增加BOSS池
func (this *CoinPoolManager) AddBossPond(sceneType int32, score int64) {
	value, ok := this.bossPond.Load(sceneType)
	if ok {
		sumValue := value.(int64) + score
		if sumValue > math.MaxInt64 {
			sumValue = math.MaxInt64
		}
		this.bossPond.Store(sceneType, sumValue)
	} else {
		this.bossPond.Store(sceneType, score)
	}
}

// 获取当前BOSS池
func (this *CoinPoolManager) GetBossPond(sceneType int32) int64 {
	value, ok := this.bossPond.Load(sceneType)
	if ok {
		return value.(int64)
	}
	return 0
}

// 增加公共奖池 暂时无用
func (this *CoinPoolManager) AddPublicPond(roomId int32, score int64) {
	value, ok := this.publicPond.Load(roomId)
	if ok {
		this.publicPond.Store(roomId, value.(int64)+score)
	} else {
		this.publicPond.Store(roomId, score)
	}
}

// 获取公共奖池
func (this *CoinPoolManager) GetPublicPond(roomId int32) int64 {
	value, ok := this.publicPond.Load(roomId)
	if ok {
		return value.(int64)
	}
	return 0
}
