package main

import (
	"math/rand"
	"time"

	"mongo.games.com/goserver/core"
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/module"
	"mongo.games.com/goserver/core/transact"
	"mongo.games.com/goserver/srvlib"

	"mongo.games.com/game/common"
	"mongo.games.com/game/proto"
	hall_proto "mongo.games.com/game/protocol/gamehall"
	"mongo.games.com/game/protocol/server"
	server_proto "mongo.games.com/game/protocol/server"
	"mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/srvdata"
)

var CoinSceneMgrSingleton = &CoinSceneMgr{
	playerChanging: make(map[int32]int32),
	//按平台管理
	scenesOfPlatform: make(map[string]map[int32]*CoinScenePool),
	platformOfScene:  make(map[int32]string),
	//按组管理
	scenesOfGroup: make(map[int32]map[int32]*CoinScenePool),
	groupOfScene:  make(map[int32]int32),
}

type CreateRoomCache struct {
	gameFreeId   int32
	platformName string
}

type CoinSceneMgr struct {
	playerChanging map[int32]int32 // snid:gamefreeid 换桌中的玩家

	//按平台管理
	scenesOfPlatform map[string]map[int32]*CoinScenePool // platform:gamefreeid
	platformOfScene  map[int32]string                    // sceneid:platform; 创建房间后记录房间所在平台

	//按组管理
	scenesOfGroup map[int32]map[int32]*CoinScenePool // groupid:gamefreeid
	groupOfScene  map[int32]int32                    // sceneid:groupid;

	//延迟创建房间列表
	delayCache []CreateRoomCache // 待预创建房间
}

// GetCoinScenePool 获取一个场景池
// plt 平台id
// id 场次id
func (csm *CoinSceneMgr) GetCoinScenePool(plt string, id int32) *CoinScenePool {
	gf := PlatformMgrSingleton.GetGameFree(plt, id)
	if gf == nil {
		return nil
	}
	groupId := gf.GetGroupId()
	if groupId != 0 {
		if _, ok := csm.scenesOfGroup[groupId]; ok {
			if csp, ok := csm.scenesOfGroup[groupId][id]; ok {
				return csp
			}
		}
	} else {
		if ss, ok := csm.scenesOfPlatform[plt]; ok {
			if csp, ok := ss[id]; ok && csp != nil {
				return csp
			}
		}
	}

	var dbGameFree *server_proto.DB_GameFree
	if groupId != 0 {
		conf := PlatformGameGroupMgrSington.GetGameGroup(groupId)
		if conf != nil {
			dbGameFree = conf.GetDbGameFree()
		}
	}
	if dbGameFree == nil {
		dbGameFree = gf.GetDbGameFree()
	}
	if dbGameFree == nil {
		return nil
	}

	// 创建了一个新的
	// 应该是走不到这里，因为模块启动时所有场次都创建了房间池
	return NewCoinScenePool(plt, groupId, dbGameFree)
}

func (csm *CoinSceneMgr) findCoinScenePool(platform string, id int32) (pools map[int32]*CoinScenePool, groupID int32,
	dbGameFree *server.DB_GameFree) {
	gf := PlatformMgrSingleton.GetGameFree(platform, id)
	if gf == nil {
		return nil, 0, nil
	}
	groupId := gf.GetGroupId()

	var ss map[int32]*CoinScenePool
	var ok bool
	if groupId != 0 {
		pgg := PlatformGameGroupMgrSington.GetGameGroup(groupId)
		if pgg != nil {
			ss, ok = csm.scenesOfGroup[groupId]
			if !ok {
				ss = make(map[int32]*CoinScenePool)
				csm.scenesOfGroup[groupId] = ss
			}
			return ss, groupId, pgg.GetDbGameFree()
		}
	}

	if ss == nil {
		ss, ok = csm.scenesOfPlatform[platform]
		if !ok {
			ss = make(map[int32]*CoinScenePool)
			csm.scenesOfPlatform[platform] = ss
		}
		return ss, 0, gf.GetDbGameFree()
	}

	return nil, 0, nil
}

// PlayerEnter 玩家进入房间池
func (csm *CoinSceneMgr) PlayerEnter(p *Player, id int32, roomId int32, exclude []int32, ischangeroom bool) hall_proto.OpResultCode {
	logger.Logger.Tracef("(csm *CoinSceneMgr) PlayerEnter snid:%v id:%v roomid:%v exclude:%v", p.SnId, id, roomId, exclude)
	if p.isDelete { //删档用户不让进游戏
		return hall_proto.OpResultCode_OPRC_RoomHadClosed
	}

	//多平台支持
	platform := p.GetPlatform()
	if platform == nil {
		return hall_proto.OpResultCode_OPRC_RoomHadClosed
	}

	// 玩家已经在房间里了
	if p.scene != nil {
		logger.Logger.Warnf("(csm *CoinSceneMgr) PlayerEnter snid:%v find in gameId:%v gamefreeid:%v", p.SnId, p.scene.gameId, id)
		return hall_proto.OpResultCode_OPRC_Error
	}

	pools, groupID, free := csm.findCoinScenePool(platform.IdStr, id)
	if pools == nil {
		return hall_proto.OpResultCode_OPRC_RoomHadClosed
	}

	csp, ok := pools[id]
	if !ok || csp == nil {
		csp = NewCoinScenePool(platform.IdStr, groupID, free)
		if csp == nil {
			logger.Logger.Warnf("(csm *CoinSceneMgr) PlayerEnter snid:%v find in id:%v exclude:%v NewCoinScenePool failed", p.SnId, id, exclude)
			return hall_proto.OpResultCode_OPRC_Error
		}
		pools[id] = csp
	}

	ret := csp.PlayerEnter(p, roomId, exclude, ischangeroom)

	logger.Logger.Warnf("(csm *CoinSceneMgr) PlayerEnter snid:%v find in id:%v exclude:%v return false", p.SnId, id, exclude)
	return ret
}

// AudienceEnter 观众进入房间
func (csm *CoinSceneMgr) AudienceEnter(p *Player, id int32, roomId int32, exclude []int32, ischangeroom bool) hall_proto.OpResultCode {
	//多平台支持
	platform := p.GetPlatform()
	if platform == nil {
		return hall_proto.OpResultCode_OPRC_RoomHadClosed
	}

	pools, _, _ := csm.findCoinScenePool(platform.IdStr, id)
	if pools == nil {
		return hall_proto.OpResultCode_OPRC_RoomHadClosed
	}

	if len(pools) == 0 {
		return hall_proto.OpResultCode_OPRC_NoFindDownTiceRoom
	}

	if csp, ok := pools[id]; ok && csp != nil {
		ret := csp.AudienceEnter(p, roomId, exclude, ischangeroom)
		logger.Logger.Warnf("(csm *CoinSceneMgr) AudienceEnter snid:%v find in id:%v exclude:%v return false", p.SnId, id, exclude)
		return ret
	}
	logger.Logger.Warnf("(csm *CoinSceneMgr) AudienceEnter snid:%v find in id:%v exclude:%v csp.AudienceEnter return false", p.SnId, id, exclude)
	return hall_proto.OpResultCode_OPRC_Error
}

func (csm *CoinSceneMgr) playerLeave(p *Player, reason int) bool {
	if p == nil || p.scene == nil {
		return true
	}

	s := p.scene
	if s.groupId != 0 {
		if ss, ok := csm.scenesOfGroup[s.groupId]; ok && ss != nil {
			if csp, ok := ss[s.dbGameFree.GetId()]; ok && csp != nil {
				if !csp.PlayerLeave(p, reason) {
					csp.AudienceLeave(p, reason)
				}
			}
			return true
		}
	}

	// 玩家身上平台
	if platform := p.GetPlatform(); platform != nil {
		if ss, ok := csm.scenesOfPlatform[platform.IdStr]; ok && ss != nil {
			if csp, ok := ss[s.dbGameFree.GetId()]; ok && csp != nil {
				if !csp.PlayerLeave(p, reason) {
					csp.AudienceLeave(p, reason)
				}
			}
			return true
		}
	}

	// 房间所在平台
	if s.limitPlatform != nil {
		if ss, ok := csm.scenesOfPlatform[s.limitPlatform.IdStr]; ok && ss != nil {
			if csp, ok := ss[s.dbGameFree.GetId()]; ok && csp != nil {
				if !csp.PlayerLeave(p, reason) {
					csp.AudienceLeave(p, reason)
				}
			}
			return true
		}
	}

	return true
}

// PlayerLeave 玩家离开
func (csm *CoinSceneMgr) PlayerLeave(p *Player, reason int) bool {
	logger.Logger.Tracef("玩家离开: snid %v, reason %v isAudience %v", p.SnId, reason)
	return csm.playerLeave(p, reason)
}

// OnDestroyScene 解散房间
// sceneId 房间id
func (csm *CoinSceneMgr) OnDestroyScene(sceneId int) {
	if platformName, ok := csm.platformOfScene[int32(sceneId)]; ok {
		if ss, ok := csm.scenesOfPlatform[platformName]; ok {
			for _, csp := range ss {
				csp.OnDestroyScene(sceneId)
			}
		}
		delete(csm.platformOfScene, int32(sceneId))
	}

	if groupId, ok := csm.groupOfScene[int32(sceneId)]; ok {
		if ss, ok := csm.scenesOfGroup[groupId]; ok {
			for _, csp := range ss {
				csp.OnDestroyScene(sceneId)
			}
		}
		delete(csm.groupOfScene, int32(sceneId))
	}
}

// GetPlatformBySceneId 获取房间所在平台
func (csm *CoinSceneMgr) GetPlatformBySceneId(sceneId int) string {
	if platformName, ok := csm.platformOfScene[int32(sceneId)]; ok {
		return platformName
	}
	s := SceneMgrSingleton.GetScene(sceneId)
	if s != nil && s.limitPlatform != nil {
		return s.limitPlatform.IdStr
	}
	return DefaultPlatform
}

// GetPlayerNums 获取场次人数
func (csm *CoinSceneMgr) GetPlayerNums(p *Player, gameId, gameMode int32) []int32 {
	//多平台支持
	platform := p.GetPlatform()
	var nums [10]int32
	wantNum := [10]int32{80, 50, 30, 20, 10, 10, 10, 10, 10, 10}
	for i := 0; i < 10; i++ {
		if wantNum[i]/2 > 0 {
			nums[i] = rand.Int31n(wantNum[i]/2) + wantNum[i]
		}
	}
	if platform == nil {
		return nums[:]
	}
	ids, _ := srvdata.DataMgr.GetGameFreeIds(gameId, gameMode)
	for _, id := range ids {
		gps := PlatformMgrSingleton.GetGameFree(platform.IdStr, id)
		if gps != nil {
			if gps.GroupId != 0 {
				if ss, exist := csm.scenesOfGroup[gps.GroupId]; exist {
					if csp, exist := ss[id]; exist {
						sceneType := csp.GetSceneType() - 1
						if sceneType >= 0 && sceneType < len(nums) {
							nums[sceneType] += csp.GetPlayerNum() + csp.GetFakePlayerNum()
						}
					}
				}
			} else {
				if ss, ok := csm.scenesOfPlatform[platform.IdStr]; ok {
					if csp, exist := ss[id]; exist {
						sceneType := csp.GetSceneType() - 1
						if sceneType >= 0 && sceneType < len(nums) {
							nums[sceneType] += csp.GetPlayerNum() + csp.GetFakePlayerNum()
						}
					}
				}
			}
		}
	}

	if len(ids) <= 10 {
		return nums[:len(ids)]
	}
	return nums[:]
}

// InCoinScene 是否在场次中
func (csm *CoinSceneMgr) InCoinScene(p *Player) bool {
	if p == nil {
		logger.Logger.Tracef("(csm *CoinSceneMgr) InCoinScene p == nil snid:%v ", p.SnId)
		return false
	}

	if p.scene == nil {
		return false
	}

	if p.scene.csp == nil {
		return false
	}
	return true
}

// PlayerTryLeave 通知游戏服务玩家要离开房间
func (csm *CoinSceneMgr) PlayerTryLeave(p *Player, isAudience bool) hall_proto.OpResultCode {
	if !csm.InCoinScene(p) {
		logger.Logger.Tracef("(csm *CoinSceneMgr) PlayerTryLeave !csm.InCoinScene(p) snid:%v ", p.SnId)
		return hall_proto.OpResultCode_OPRC_Sucess
	}

	// 通知gamesrv
	op := common.CoinSceneOp_Leave
	if isAudience {
		op = common.CoinSceneOp_AudienceLeave
	}
	pack := &hall_proto.CSCoinSceneOp{
		Id:     proto.Int32(p.scene.csp.id),
		OpType: proto.Int32(op),
	}
	proto.SetDefaults(pack)
	common.TransmitToServer(p.sid, int(hall_proto.CoinSceneGamePacketID_PACKET_CS_COINSCENE_OP), pack, p.scene.gameSess.Session)
	logger.Logger.Tracef("(csm *CoinSceneMgr) PlayerTryLeave snid:%v id:%v", p.SnId, pack.GetId())
	return hall_proto.OpResultCode_OPRC_OpYield
}

func (csm *CoinSceneMgr) PlayerInChanging(p *Player) bool {
	_, exist := csm.playerChanging[p.SnId]
	return exist
}

func (csm *CoinSceneMgr) ClearPlayerChanging(p *Player) {
	delete(csm.playerChanging, p.SnId)
}

func (csm *CoinSceneMgr) PlayerTryChange(p *Player, id int32, exclude []int32, isAudience bool) hall_proto.OpResultCode {
	if csm.InCoinScene(p) {
		return csm.StartChangeCoinSceneTransact(p, id, exclude, isAudience)
	}

	if isAudience {
		return csm.AudienceEnter(p, id, 0, exclude, true)
	}
	return csm.PlayerEnter(p, id, 0, exclude, true)
}

func (csm *CoinSceneMgr) StartChangeCoinSceneTransact(p *Player, id int32, exclude []int32, isAudience bool) hall_proto.OpResultCode {
	if p == nil || p.scene == nil {
		logger.Logger.Warnf("(csm *CoinSceneMgr) StartChangeCoinSceneTransact p == nil || p.scene == nil snid:%v id:%v", p.SnId, id)
		return hall_proto.OpResultCode_OPRC_Error
	}

	tNow := time.Now()
	if !p.lastChangeScene.IsZero() && tNow.Sub(p.lastChangeScene) < time.Second {
		logger.Logger.Warnf("(csm *CoinSceneMgr) StartChangeCoinSceneTransact !p.lastChangeScene.IsZero() && tNow.Sub(p.lastChangeScene) < time.Second snid:%v id:%v", p.SnId, id)
		return hall_proto.OpResultCode_OPRC_ChangeRoomTooOften
	}

	tnp := &transact.TransNodeParam{
		Tt:     common.TransType_CoinSceneChange,
		Ot:     transact.TransOwnerType(common.GetSelfSrvType()),
		Oid:    common.GetSelfSrvId(),
		AreaID: common.GetSelfAreaId(),
	}
	ctx := &CoinSceneChangeCtx{
		id:         id,
		isClub:     false,
		snid:       p.SnId,
		sceneId:    int32(p.scene.sceneId),
		exclude:    exclude,
		isAudience: isAudience,
	}
	tNode := transact.DTCModule.StartTrans(tnp, ctx, CoinSceneChangeTimeOut)
	if tNode != nil {
		tNode.Go(core.CoreObject())
		csm.playerChanging[p.SnId] = id
		p.lastChangeScene = tNow
		return hall_proto.OpResultCode_OPRC_Sucess
	}
	logger.Logger.Warnf("(csm *CoinSceneMgr) StartChangeCoinSceneTransact tNode == nil snid:%v id:%v", p.SnId, id)
	return hall_proto.OpResultCode_OPRC_Error
}

// ListRooms 给客户端发送场次房间列表
// id 场次id
func (csm *CoinSceneMgr) ListRooms(p *Player, id int32) bool {
	//多平台支持
	platform := p.GetPlatform()
	if platform == nil {
		return false
	}

	pools, groupID, free := csm.findCoinScenePool(platform.IdStr, id)
	if pools == nil {
		return false
	}

	if csp, ok := pools[id]; ok && csp != nil {
		return csp.ListRoom(p)
	}
	csp := NewCoinScenePool(platform.IdStr, groupID, free)
	if csp == nil {
		return false
	}
	pools[id] = csp
	return csp.ListRoom(p)
}

// CreateRoomByCache 创建预创建房间
// 每2秒创建一次
func (csm *CoinSceneMgr) CreateRoomByCache() {
	cnt := len(csm.delayCache)
	if cnt > 0 {
		data := csm.delayCache[cnt-1]
		csm.delayCache = csm.delayCache[:cnt-1]
		pdd := PlatformMgrSingleton.GetGameFree(data.platformName, data.gameFreeId)
		//对战场和捕鱼场 预创建
		if pdd != nil && pdd.DbGameFree != nil {
			var ss map[int32]*CoinScenePool
			var ok bool
			//分组模式
			if pdd.GroupId != 0 {
				pgg := PlatformGameGroupMgrSington.GetGameGroup(pdd.GroupId)
				if pgg != nil {
					ss, ok = csm.scenesOfGroup[pdd.GroupId]
					if !ok {
						ss = make(map[int32]*CoinScenePool)
						csm.scenesOfGroup[pdd.GroupId] = ss
					}
				}
			}
			//独立模式
			if ss == nil {
				ss, ok = csm.scenesOfPlatform[data.platformName]
				if !ok {
					ss = make(map[int32]*CoinScenePool)
					csm.scenesOfPlatform[data.platformName] = ss
				}
			}
			if ss == nil {
				return
			}
			if csp, ok := ss[pdd.DbGameFree.Id]; ok && csp != nil {
				csp.PreCreateRoom()
				return
			}
			csp := NewCoinScenePool(data.platformName, 0, pdd.DbGameFree)
			if csp != nil {
				ss[pdd.DbGameFree.Id] = csp
				csp.PreCreateRoom()
				return
			}
		}
	}
}

func (csm *CoinSceneMgr) ModuleName() string {
	return "CoinSceneMgr"
}

func (csm *CoinSceneMgr) Init() {
	// 场次池预创建
	for _, platform := range PlatformMgrSingleton.GetPlatforms() {
		if platform.Isolated || platform.IdStr == "" {
			arr := srvdata.PBDB_GameFreeMgr.Datas.GetArr()
			for _, dbGame := range arr {
				gps := PlatformMgrSingleton.GetGameFree(platform.IdStr, dbGame.GetId())
				if gps != nil {
					// dbGameFree
					dbGameFree := gps.DbGameFree
					if gps.GroupId != 0 {
						pgg := PlatformGameGroupMgrSington.GetGameGroup(gps.GroupId)
						if pgg != nil {
							dbGameFree = pgg.DbGameFree
						}
					}
					// CoinScenePool
					csp := NewCoinScenePool(platform.IdStr, gps.GroupId, dbGameFree)
					if csp != nil {
						if gps.GroupId != 0 {
							if ss, exist := csm.scenesOfGroup[gps.GroupId]; exist {
								ss[dbGame.GetId()] = csp
							} else {
								ss = make(map[int32]*CoinScenePool)
								ss[dbGame.GetId()] = csp
								csm.scenesOfGroup[gps.GroupId] = ss
							}
						} else {
							if ss, exist := csm.scenesOfPlatform[platform.IdStr]; exist {
								ss[dbGame.GetId()] = csp
							} else {
								ss = make(map[int32]*CoinScenePool)
								ss[dbGame.GetId()] = csp
								csm.scenesOfPlatform[platform.IdStr] = ss
							}
						}
					}
				}
			}
		}
	}
}

func (csm *CoinSceneMgr) Update() {
	// 预创建房间
	csm.CreateRoomByCache()
}

func (csm *CoinSceneMgr) Shutdown() {
	module.UnregisteModule(csm)
}

//=====================PlatformObserver======================

func (this *CoinSceneMgr) OnPlatformCreate(p *Platform) {
	if p.IdStr == DefaultPlatform {
		return
	}
	//获取配置
	gps := PlatformMgrSingleton.GetGameFrees(p.IdStr)
	for _, v := range gps {
		if v.Status && v.DbGameFree.GetCreateRoomNum() > 0 {
			this.delayCache = append(this.delayCache, CreateRoomCache{gameFreeId: v.DbGameFree.Id, platformName: p.IdStr})
		}
	}
}

func (this *CoinSceneMgr) OnPlatformDestroy(p *Platform) {
	if p == nil {
		return
	}
	if csps, ok := this.scenesOfPlatform[p.IdStr]; ok {
		for _, csp := range csps {
			pack := &server_proto.WGGraceDestroyScene{}
			for _, scene := range csp.scenes {
				pack.Ids = append(pack.Ids, int32(scene.sceneId))
			}
			// 房间中记录的有游服连接，广播的方式也可以
			srvlib.ServerSessionMgrSington.Broadcast(int(server_proto.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE), pack, common.GetSelfAreaId(), srvlib.GameServerType)
		}
	}
}

func (this *CoinSceneMgr) OnPlatformChangeIsolated(p *Platform, isolated bool) {
	if !isolated {
		this.OnPlatformDestroy(p)
	}
}

func (this *CoinSceneMgr) OnPlatformChangeDisabled(p *Platform, disabled bool) {
	if disabled {
		this.OnPlatformDestroy(p)
	}
}

func (this *CoinSceneMgr) OnPlatformGameFreeUpdate(p *Platform, oldCfg, newCfg *webapi.GameFree) {
	if p == nil || newCfg == nil {
		return
	}

	var ss map[int32]*CoinScenePool
	var ok bool
	if oldCfg.GroupId != newCfg.GroupId || oldCfg.GroupId != 0 {
		ss, ok = this.scenesOfGroup[oldCfg.GroupId]
	} else {
		ss, ok = this.scenesOfPlatform[p.IdStr]
	}
	if !ok || ss == nil {
		return
	}

	if cps, ok := ss[newCfg.DbGameFree.Id]; ok {
		cps.dbGameFree = newCfg.DbGameFree
		pack := &server_proto.WGGraceDestroyScene{}
		for _, scene := range cps.scenes {
			pack.Ids = append(pack.Ids, int32(scene.sceneId))
		}
		srvlib.ServerSessionMgrSington.Broadcast(int(server_proto.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE),
			pack, common.GetSelfAreaId(), srvlib.GameServerType)

		//预创建房间配置更新
		if newCfg.DbGameFree.GetCreateRoomNum() != 0 && p.IdStr != DefaultPlatform && newCfg.Status {
			logger.Logger.Tracef(">>>预创建房间 platform:%v %v_%v gamefreeid:%v CreateRoomNum:%v", p.Name,
				newCfg.DbGameFree.GetName(), newCfg.DbGameFree.GetTitle(), newCfg.DbGameFree.GetId(), newCfg.DbGameFree.GetCreateRoomNum())
			this.delayCache = append(this.delayCache, CreateRoomCache{gameFreeId: newCfg.DbGameFree.GetId(), platformName: p.IdStr})
		}
	}
}

func (this *CoinSceneMgr) OnPlatformDestroyByGameFreeId(p *Platform, gameFreeId int32) {
	if p == nil {
		return
	}
	if csps, ok := this.scenesOfPlatform[p.IdStr]; ok {
		for _, csp := range csps {
			pack := &server_proto.WGGraceDestroyScene{}
			for _, scene := range csp.scenes {
				if scene.dbGameFree.Id == gameFreeId {
					pack.Ids = append(pack.Ids, int32(scene.sceneId))
				}
			}
			srvlib.ServerSessionMgrSington.Broadcast(int(server_proto.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE), pack, common.GetSelfAreaId(), srvlib.GameServerType)
		}
	}
}

//=========================PlatformGameGroupObserver==============================

func (this *CoinSceneMgr) OnGameGroupUpdate(oldCfg, newCfg *webapi.GameConfigGroup) {
	if newCfg == nil {
		return
	}
	if scenes, exist := this.scenesOfGroup[newCfg.Id]; exist {
		if cps, ok := scenes[newCfg.DbGameFree.Id]; ok {
			needDestroy := false
			if cps.dbGameFree.GetBot() != newCfg.DbGameFree.GetBot() ||
				cps.dbGameFree.GetBaseScore() != newCfg.DbGameFree.GetBaseScore() ||
				cps.dbGameFree.GetLimitCoin() != newCfg.DbGameFree.GetLimitCoin() ||
				cps.dbGameFree.GetMaxCoinLimit() != newCfg.DbGameFree.GetMaxCoinLimit() ||
				cps.dbGameFree.GetTaxRate() != newCfg.DbGameFree.GetTaxRate() ||
				!common.SliceInt64Equal(cps.dbGameFree.GetOtherIntParams(), newCfg.DbGameFree.GetOtherIntParams()) ||
				!common.SliceInt64Equal(cps.dbGameFree.GetRobotTakeCoin(), newCfg.DbGameFree.GetRobotTakeCoin()) ||
				!common.SliceInt64Equal(cps.dbGameFree.GetRobotLimitCoin(), newCfg.DbGameFree.GetRobotLimitCoin()) {
				needDestroy = true
			}
			//TODO 预创建房间配置更新,unsupport group model
			cps.dbGameFree = newCfg.DbGameFree
			if needDestroy {
				pack := &server_proto.WGGraceDestroyScene{}
				for _, scene := range cps.scenes {
					pack.Ids = append(pack.Ids, int32(scene.sceneId))
				}
				srvlib.ServerSessionMgrSington.Broadcast(int(server_proto.SSPacketID_PACKET_WG_GRACE_DESTROYSCENE), pack, common.GetSelfAreaId(), srvlib.GameServerType)
			}
		}
	}
}

//=========================GameSessionListener======================================

func (csm *CoinSceneMgr) OnGameSessionRegiste(gs *GameSession) {
	wildGs := len(gs.gameIds) == 0 || common.InSliceInt32(gs.gameIds, 0) // 是否所有游戏都支持
	for _, platform := range PlatformMgrSingleton.GetPlatforms() {
		if platform.IdStr == DefaultPlatform {
			continue
		}
		//获取配置
		gps := PlatformMgrSingleton.GetGameFrees(platform.IdStr)
		for _, v := range gps {
			if v.Status && v.DbGameFree.GetCreateRoomNum() > 0 && (wildGs || common.InSliceInt32(gs.gameIds, v.DbGameFree.GetGameId())) {
				csm.delayCache = append(csm.delayCache, CreateRoomCache{gameFreeId: v.DbGameFree.Id, platformName: platform.IdStr})
			}
		}
	}
}

func (this *CoinSceneMgr) OnGameSessionUnregiste(gs *GameSession) {
	//todo 游戏服务断开，是否解散房间？
}

func init() {
	module.RegisteModule(CoinSceneMgrSingleton, time.Second*2, 0)

	PlatformMgrSingleton.RegisterObserver(CoinSceneMgrSingleton)
	PlatformGameGroupMgrSington.RegisteObserver(CoinSceneMgrSingleton)
	RegisteGameSessionListener(CoinSceneMgrSingleton)
}