package main

import (
	"fmt"
	"math/rand"
	"slices"
	"sort"
	"time"

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

	"mongo.games.com/game/common"
	"mongo.games.com/game/model"
	"mongo.games.com/game/proto"
	"mongo.games.com/game/protocol/gamehall"
	"mongo.games.com/game/protocol/server"
	webapiproto "mongo.games.com/game/protocol/webapi"
	"mongo.games.com/game/srvdata"
)

type CSEnterRoomPacketFactory struct {
}
type CSEnterRoomHandler struct {
}

func (this *CSEnterRoomPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSEnterRoom{}
	return pack
}
func (this *CSEnterRoomHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSEnterRoomHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSEnterRoom)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	var code = gamehall.OpResultCode_Game_OPRC_Sucess_Game
	var sp ScenePolicy
	var dbGameFree *server.DB_GameFree
	var roomId int
	var gameId int
	var gameMode int
	var cfg *webapiproto.GameFree
	oldPlatform := p.Platform

	// 进入原来的房间
	scene := p.scene
	if scene != nil {
		code = gamehall.OpResultCode_Game_OPRC_GameStarting_Game
		roomId = scene.sceneId
		gameId = scene.gameId
		gameMode = scene.gameMode
		logger.Logger.Tracef("CSEnterRoomHandler had scene(%d)", scene.sceneId)
		goto failed
	}

	// 房间查询
	scene = SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
	if scene == nil {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Trace("CSEnterRoomHandler scene == nil")
		goto failed
	}

	gameId = scene.gameId
	gameMode = scene.gameMode
	roomId = scene.sceneId
	if p.IsRob {
		p.Platform = scene.platform.IdStr
	}

	cfg = PlatformMgrSingleton.GetGameFree(p.Platform, scene.dbGameFree.Id)
	if cfg != nil && (cfg.GroupId != scene.groupId || cfg.GroupId == 0) {
		if scene.platform != nil {
			if scene.platform.Isolated && p.Platform != scene.platform.IdStr {
				code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
				logger.Logger.Tracef("CSEnterRoomHandler ScenePolicy(gameid:%v mode:%v) scene.platform.Isolated && p.Platform != scene.platform.Name", scene.gameId, scene.gameMode)
				goto failed
			}
		}
	}
	if scene.deleting {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Trace("CSEnterRoomHandler scene is deleting")
		goto failed
	}
	if scene.closed {
		code = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		logger.Logger.Trace("CSEnterRoomHandler scene is closed")
		goto failed
	}

	// 密码是否正确
	if scene.GetPassword() != "" && scene.GetPassword() != msg.GetPassword() {
		code = gamehall.OpResultCode_Game_OPRC_PasswordError
		logger.Logger.Trace("CSEnterRoomHandler password error")
		goto failed
	}
	// 房费是否充足
	if scene.IsCustom() {
		cfg := PlatformMgrSingleton.GetConfig(p.Platform).RoomConfig[scene.CustomParam.RoomConfigId]
		if scene.CustomParam.CostType == 1 && !scene.sp.CostEnough(int(scene.CustomParam.CostType), scene.playerNum, cfg, p.SnId) {
			code = gamehall.OpResultCode_Game_OPRC_CostNotEnough
			logger.Logger.Trace("CSEnterRoomHandler cost error")
			goto failed
		}
	}

	dbGameFree = scene.dbGameFree
	if dbGameFree != nil {
		if common.IsLocalGame(scene.gameId) {
			if !p.IsRob {
				limitCoin := srvdata.CreateRoomMgrSington.GetLimitCoinByBaseScore(int32(scene.gameId), scene.dbGameFree.GetSceneType(), scene.BaseScore)
				if p.Coin < limitCoin {
					code = gamehall.OpResultCode_Game_OPRC_CoinNotEnough_Game
					logger.Logger.Trace("CSEnterRoomHandler scene is closed")
					goto failed
				}
			}
		}
	}

	//检测房间状态是否开启
	if !scene.IsMatchScene() && !PlatformMgrSingleton.CheckGameState(scene.platform.IdStr, dbGameFree.Id) {
		code = gamehall.OpResultCode_Game_OPRC_GameHadClosed
		logger.Logger.Tracef("CSEnterRoomHandler SnId:%v GameFreeId:%v GameHadClosed", p.SnId, dbGameFree.Id)
		goto failed
	}

	sp = GetScenePolicy(scene.gameId, scene.gameMode)
	if sp == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSEnterRoomHandler ScenePolicy(gameid:%v mode:%v) not registe", scene.gameId, scene.gameMode)
		goto failed
	}

	if reason := sp.CanEnter(scene, p.SnId); reason != 0 {
		code = gamehall.OpResultCode_Game(reason)
		logger.Logger.Trace("CSEnterRoomHandler sp.CanEnter(scene, p) reason ", reason)
		goto failed
	}

	if scene.IsFull() {
		code = gamehall.OpResultCode_Game_OPRC_RoomIsFull_Game
		logger.Logger.Trace("CSEnterRoomHandler ScenePolicy.IsFull = true")
		goto failed
	}

	if scene.IsMatchScene() && p.IsRob {
		grade := int32(1000)
		snid := p.SnId
		roleId := int32(2000001)
		if p.Roles != nil {
			roleId = p.Roles.ModId
		}
		skinId := int32(300001)
		var tm *TmMatch
		if scene.MatchSortId > 0 {
			tm = TournamentMgr.GetTm(scene.MatchSortId)
			if tm != nil && tm.copyRobotGrades != nil && len(tm.copyRobotGrades) > 0 {
				randIndex := rand.Intn(len(tm.copyRobotGrades))
				grade = tm.copyRobotGrades[randIndex].grade
				snid = tm.copyRobotGrades[randIndex].copySnid
				roleId = tm.copyRobotGrades[randIndex].copyRoleId
				skinId = tm.copyRobotGrades[randIndex].CopySkinId
				tm.copyRobotGrades = append(tm.copyRobotGrades[:randIndex], tm.copyRobotGrades[randIndex+1:]...)
			}
		}
		mc := NewMatchContext(p, tm, grade, snid, 1, roleId, skinId, 0)
		if mc != nil {
			mc.gaming = true
			p.matchCtx = mc
		}
	}

	if !scene.PlayerEnter(p, -1, true) {
		code = gamehall.OpResultCode_Game_OPRC_Error_Game
	}

failed:
	if code != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
		resp := &gamehall.SCEnterRoom{
			GameId:    proto.Int(gameId),
			ModeType:  proto.Int(gameMode),
			RoomId:    proto.Int(roomId),
			OpRetCode: code,
		}
		p.Platform = oldPlatform
		proto.SetDefaults(resp)
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_ENTERROOM), resp)
	}
	return nil
}

type CSReturnRoomPacketFactory struct {
}
type CSReturnRoomHandler struct {
}

func (this *CSReturnRoomPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSReturnRoom{}
	return pack
}
func (this *CSReturnRoomHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSReturnRoomHandler Process recv ", data)
	if msg, ok := data.(*gamehall.CSReturnRoom); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			return nil
		}
		scene := p.scene
		pack := &gamehall.SCReturnRoom{}
		if scene == nil {
			//miniGameScene := MiniGameMgrSington.GetAllSceneByPlayer(p)
			isExist := false
			//for _, s := range miniGameScene {
			//	if s.sceneId == int(msg.GetRoomId()) {
			//		isExist = true
			//	}
			//}
			if isExist {
				//如果存在这尝试返回到房间内
				//MiniGameMgrSington.OnPlayerReturnScene(p)
			} else {
				pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
				//如果不存在则直接返回
				goto done
			}
		} else {
			pack.RoomId = proto.Int(scene.sceneId)
			pack.GameId = proto.Int(scene.gameId)
			pack.ModeType = proto.Int(scene.gameMode)
			pack.Params = common.CopySliceInt64ToInt32(scene.params)
			pack.HallId = proto.Int32(scene.dbGameFree.GetId())
			gameVers := srvdata.GetGameVers(p.PackageID)
			if ver, ok := gameVers[fmt.Sprintf("%v,%v", scene.gameId, p.Channel)]; ok {
				pack.MinApkVer = proto.Int32(ver.MinApkVer)
				pack.MinResVer = proto.Int32(ver.MinResVer)
				pack.LatestApkVer = proto.Int32(ver.LatestApkVer)
				pack.LatestResVer = proto.Int32(ver.LatestResVer)

				if msg.GetApkVer() < ver.MinApkVer {
					pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_YourAppVerIsLow_Game
					goto done
				}

				if msg.GetResVer() < ver.MinResVer {
					pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_YourResVerIsLow_Game
					goto done
				}
			}
			scene = p.ReturnScene(msg.GetIsLoaded())
			if scene == nil {
				pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
			} else {
				//成功返回房间的消息在gamesrv上发送，为了确保房间消息的顺序
				return nil
				//pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_Sucess_Game
			}
		}
	done:
		proto.SetDefaults(pack)
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_RETURNROOM), pack)
	}
	return nil
}

type CSQueryRoomInfoPacketFactory struct {
}
type CSQueryRoomInfoHandler struct {
}

func (this *CSQueryRoomInfoPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSQueryRoomInfo{}
	return pack
}

func (this *CSQueryRoomInfoHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	//msg, ok := data.(*gamehall.CSQueryRoomInfo)
	//if !ok {
	//	return nil
	//}
	//if len(msg.GetId()) > 0 {
	//	return this.ProcessId(s, packetid, data, sid)
	//}
	return this.ProcessLocalGame(s, packetid, data, sid)
}

func (this *CSQueryRoomInfoHandler) ProcessLocalGame(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSQueryRoomInfoHandler Process recv ProcessLocalGame", data)
	if msg, ok := data.(*gamehall.CSQueryRoomInfo); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSQueryRoomInfoHandler p == nil")
			return nil
		}
		pack := &gamehall.SCQueryRoomInfo{
			GameSite: proto.Int32(msg.GetGameSite()),
		}
		mapGameCfg := PlatformMgrSingleton.GetGameFrees(p.Platform)
		for _, gameid := range msg.GetGameIds() {
			pack.GameIds = append(pack.GameIds, gameid)
			scenes := SceneMgrSingleton.GetScenesByGame(int(gameid))
			for _, scene := range scenes {
				if scene == nil {
					continue
				}
				var isShow bool
				if mapGameCfg != nil {
					if cfg, have := mapGameCfg[scene.dbGameFree.Id]; have && cfg.GroupId != 0 && cfg.GroupId == scene.groupId {
						isShow = true
					}
				}
				if p.Platform == scene.platform.IdStr || isShow {
					if scene.sceneMode == int(msg.GetSceneMode()) && len(scene.players) != 0 {
						if scene.gameId == int(gameid) && scene.dbGameFree.GetSceneType() == msg.GetGameSite() {

							// 私人房需要是好友
							if scene.sceneMode == common.SceneModePrivate {
								if !FriendMgrSington.IsFriend(p.Platform, p.SnId, scene.creator) {
									continue
								}
							}

							roomInfo := &gamehall.QRoomInfo{
								GameFreeId: proto.Int32(scene.dbGameFree.GetId()),
								GameId:     proto.Int32(scene.dbGameFree.GetGameId()),
								RoomId:     proto.Int(scene.sceneId),
								BaseCoin:   proto.Int64(int64(scene.BaseScore)),
								LimitCoin:  proto.Int64(scene.dbGameFree.GetLimitCoin()),
								CurrNum:    proto.Int(scene.GetPlayerCnt()),
								MaxPlayer:  proto.Int(scene.playerNum),
								Creator:    proto.Int32(scene.creator),
								CreateTs:   proto.Int32(int32(scene.createTime.Unix())),
								Params:     common.CopySliceInt64ToInt32(scene.params),
							}
							pack.RoomInfo = append(pack.RoomInfo, roomInfo)
						}
					}
				}
			}
		}
		pack.OpRetCode = gamehall.OpResultCode_Game_OPRC_Sucess_Game
		proto.SetDefaults(pack)
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_QUERYROOMINFO), pack)
		logger.Logger.Trace("SCQueryRoomInfo: ", pack)
	}
	return nil
}

// 获取指定游戏配置 包括分场信息
type CSGetGameConfigPacketFactory struct {
}
type CSGetGameConfigHandler struct {
}

func (this *CSGetGameConfigPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSGetGameConfig{}
	return pack
}

func (this *CSGetGameConfigHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetGameConfigHandler Process recv ", data)
	if msg, ok := data.(*gamehall.CSGetGameConfig); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSGetGameConfigHandler p == nil")
			return nil
		}

		plf := msg.GetPlatform()
		if plf == "" {
			logger.Logger.Warn("CSGetGameConfigHandler plf == ''")
			return nil
		}

		chl := msg.GetChannel()
		if chl == "" {
			logger.Logger.Warn("CSGetGameConfigHandler chl == ''")
			return nil
		}

		gameId := msg.GetGameId()
		if gameId == 0 {
			logger.Logger.Warn("CSGetGameConfigHandler gameId == 0")
			return nil
		}
		p.SendGameConfig(gameId, plf, chl)
	}
	return nil
}

// 进入游戏操作
type CSEnterGamePacketFactory struct {
}
type CSEnterGameHandler struct {
}

func (this *CSEnterGamePacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSEnterGame{}
	return pack
}

func (this *CSEnterGameHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSEnterGameHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSEnterGame)
	if !ok {
		return nil
	}

	gameId := msg.GetId() //gameid
	if gameId > 10000 {
		gameId = msg.GetId() / 10000 //gamefreeid
	}

	if common.IsLocalGame(int(gameId)) {
		return this.ProcessLocal(s, packetid, data, sid)
	}
	return this.ProcessNormal(s, packetid, data, sid)
}

func (this *CSEnterGameHandler) ProcessLocal(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSEnterGameHandler ProcessLocal recv ", data)
	msg, ok := data.(*gamehall.CSEnterGame)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	// 返回消息
	var ret gamehall.OpResultCode_Game
	pack := &gamehall.SCEnterGame{
		Id: msg.Id,
	}
	oldPlatform := p.Platform
	sendEnterGame := func() {
		//机器人要避免身上的平台标记被污染
		if p.IsRob {
			if ret != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
				p.Platform = oldPlatform
			}
		}
		pack.OpCode = ret
		proto.SetDefaults(pack)
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_ENTERGAME), pack)
	}

	// 进入原房间
	if p.scene != nil {
		if p.thrscene > 0 {
			ret = gamehall.OpResultCode_Game_OPRC_InOtherGameIng_Game
			sendEnterGame()
			return nil
		}
		logger.Logger.Warnf("CSEnterGameHandler  found snid:%v had in scene:%v gameid:%v", p.SnId, p.scene.sceneId, p.scene.gameId)
		p.ReturnScene(true)
		return nil
	}

	// 获取gameId
	gameId := msg.GetId() //gameid
	if gameId > 10000 {
		gameId = msg.GetId() / 10000 //gamefreeid
	}

	// 本地游戏入场规则
	playerTakeCoin := p.Coin
	gameSite := srvdata.CreateRoomMgrSington.GetGameSiteByGameId(gameId, playerTakeCoin)
	if gameSite == 0 {
		ret = gamehall.OpResultCode_Game_OPRC_CoinNotEnough_Game
		sendEnterGame()
		return nil
	}

	gamefreeid := gameId*10000 + gameSite
	gps := PlatformMgrSingleton.GetGameFree(p.Platform, gamefreeid)
	if gps == nil {
		ret = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		sendEnterGame()
		return nil
	}

	dbGameFree := gps.DbGameFree
	var roomId int32
	params := msg.GetOpParams()

	if dbGameFree == nil {
		ret = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		sendEnterGame()
		return nil
	}

	if len(params) != 0 {
		roomId = params[0]
		platformName := SceneMgrSingleton.GetPlatformBySceneId(int(roomId))
		if p.IsRob {
			if platformName != "" {
				p.Platform = platformName
			}
		} else if p.GMLevel > 0 && p.Platform == platformName { //允许GM直接按房间ID进场
			roomId = params[0]
		}
	}

	if len(msg.GetPlatform()) > 0 && p.IsRob {
		p.Platform = msg.GetPlatform()
	}

	if len(params) != 0 && (p.GMLevel > 0 || dbGameFree.GetCreateRoomNum() != 0) { //允许GM|或者可选房间的游戏直接按房间ID进场
		s := SceneMgrSingleton.GetScene(int(params[0]))
		if s != nil {
			if s.platform.IdStr == p.Platform || (gps.GroupId != 0 && s.groupId == gps.GroupId) {
				roomId = params[0]
			}
		}
	}

	excludeSceneIds := p.lastSceneId[gamefreeid]
	ret = gamehall.OpResultCode_Game(CoinSceneMgrSingleton.PlayerEnter(p, gamefreeid, roomId, excludeSceneIds, true))
	if p.scene != nil {
		pack.OpParams = append(pack.OpParams, int32(p.scene.sceneId))
		// 有房间还进入失败，尝试returnroom
		if ret != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
			p.ReturnScene(true)
			return nil
		}
	}
	sendEnterGame()
	return nil
}

func (this *CSEnterGameHandler) ProcessNormal(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSEnterGameHandler ProcessNormal recv ", data)
	msg, ok := data.(*gamehall.CSEnterGame)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	// 返回消息
	var ret gamehall.OpResultCode_Game
	pack := &gamehall.SCEnterGame{
		Id: msg.Id,
	}
	oldPlatform := p.Platform
	sendEnterGame := func() {
		//机器人要避免身上的平台标记被污染
		if p.IsRob {
			if ret != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
				p.Platform = oldPlatform
			}
		}
		pack.OpCode = ret
		proto.SetDefaults(pack)
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_ENTERGAME), pack)
	}

	// 进入原房间
	if p.scene != nil {
		if p.thrscene > 0 {
			ret = gamehall.OpResultCode_Game_OPRC_InOtherGameIng_Game
			sendEnterGame()
			return nil
		}
		logger.Logger.Warnf("CSEnterGameHandler  found snid:%v had in scene:%v gameid:%v", p.SnId, p.scene.sceneId, p.scene.gameId)
		p.ReturnScene(true)
		return nil
	}

	// 其他游戏入场规则
	gps := PlatformMgrSingleton.GetGameFree(p.Platform, msg.GetId())
	if gps == nil {
		ret = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		sendEnterGame()
		return nil
	}

	dbGameFree := gps.DbGameFree
	if dbGameFree == nil {
		ret = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		sendEnterGame()
		return nil
	}

	gameType := dbGameFree.GetGameType()
	var roomId int32
	params := msg.GetOpParams() // 0:房间id
	switch {
	case common.IsHundredType(gameType):
		if len(params) != 0 {
			roomId = params[0]
			platform := SceneMgrSingleton.GetPlatformBySceneId(int(roomId))
			if p.IsRob {
				if platform != "" {
					p.Platform = platform
				}
			} else if p.GMLevel > 0 && p.Platform == platform { //允许GM直接按房间ID进场
				roomId = params[0]
			}
		}

		if len(params) != 0 && p.GMLevel > 0 { //允许GM直接按房间ID进场
			s := SceneMgrSingleton.GetScene(int(params[0]))
			if s != nil {
				if s.platform.IdStr == p.Platform || (s.groupId != 0 && s.groupId == gps.GroupId) {
					roomId = params[0]
				}
			}
		}
		ret = gamehall.OpResultCode_Game(HundredSceneMgrSingleton.PlayerEnter(p, msg.GetId()))
		if p.scene != nil {
			pack.OpParams = append(pack.OpParams, msg.GetId())
			if ret != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
				p.ReturnScene(true)
				return nil
			}
		}

	case common.IsCoinSceneType(gameType):
		if len(params) != 0 {
			roomId = params[0]
			platformName := SceneMgrSingleton.GetPlatformBySceneId(int(roomId))
			if p.IsRob {
				if platformName != "" {
					p.Platform = platformName
				}
			} else if p.GMLevel > 0 && p.Platform == platformName { //允许GM直接按房间ID进场
				roomId = params[0]
			}
		}
		if len(msg.GetPlatform()) > 0 && p.IsRob {
			p.Platform = msg.GetPlatform()
		}

		if len(params) != 0 && (p.GMLevel > 0 || dbGameFree.GetCreateRoomNum() != 0) { //允许GM|或者可选房间的游戏直接按房间ID进场
			s := SceneMgrSingleton.GetScene(int(params[0]))
			if s != nil {
				if s.platform.IdStr == p.Platform || (gps.GroupId != 0 && s.groupId == gps.GroupId) {
					roomId = params[0]
				}
			}
		}

		excludeSceneIds := p.lastSceneId[msg.GetId()]
		ret = gamehall.OpResultCode_Game(CoinSceneMgrSingleton.PlayerEnter(p, msg.GetId(), roomId, excludeSceneIds, true))
		if p.scene != nil {
			pack.OpParams = append(pack.OpParams, int32(p.scene.sceneId))
			if ret != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
				p.ReturnScene(true)
				return nil
			}
		}
	default:

	}
	sendEnterGame()
	return nil
}

// 退出游戏操作
type CSQuitGamePacketFactory struct {
}
type CSQuitGameHandler struct {
}

func (this *CSQuitGamePacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSQuitGame{}
	return pack
}

func (this *CSQuitGameHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSQuitGameHandler Process recv ", data)
	if msg, ok := data.(*gamehall.CSQuitGame); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p != nil {
			var ret gamehall.OpResultCode_Game
			pack := &gamehall.SCQuitGame{
				Id: msg.Id,
			}

			dbGameFree := srvdata.PBDB_GameFreeMgr.GetData(msg.GetId())
			gameType := dbGameFree.GetGameType()
			if common.IsHundredType(gameType) {
				ret = gamehall.OpResultCode_Game(HundredSceneMgrSingleton.PlayerTryLeave(p))
				if gamehall.OpResultCode_Game_OPRC_OpYield_Game == ret {
					return nil
				}
			} else if common.IsCoinSceneType(gameType) {
				ret = gamehall.OpResultCode_Game(CoinSceneMgrSingleton.PlayerTryLeave(p, msg.IsAudience))
				if gamehall.OpResultCode_Game_OPRC_OpYield_Game == ret {
					return nil
				}
			}

			pack.OpCode = ret
			proto.SetDefaults(pack)
			p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_QUITGAME), pack)
			logger.Logger.Tracef("SCQuitGame: %v", pack)
		}
	}
	return nil
}

type CSCreateRoomPacketFactory struct {
}
type CSCreateRoomHandler struct {
}

func (this *CSCreateRoomPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSCreateRoom{}
	return pack
}

func (this *CSCreateRoomHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSCreateRoomHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSCreateRoom)
	if !ok {
		return nil
	}

	switch {
	case common.IsLocalGame(int(msg.GetGameId())):
		return this.ProcessLocalGame(s, packetid, data, sid)
	default:
		logger.Logger.Errorf("CSCreateRoomHandler no create function %v", msg.GetGameId())
		return nil
	}
}

func (this *CSCreateRoomHandler) ProcessLocalGame(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	msg, ok := data.(*gamehall.CSCreateRoom)
	if !ok {
		return nil
	}
	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	var code gamehall.OpResultCode_Game
	var betRange []int32
	var inRange bool
	var dbCreateRoom *server.DB_Createroom
	var dbGameFree *server.DB_GameFree
	var dbGameRule *server.DB_GameRule
	var playerTakeCoin = p.GetCoin()
	var maxPlayerNum = int(msg.GetMaxPlayerNum())
	var gameId = msg.GetGameId()
	var params = common.CopySliceInt32ToInt64(msg.GetParams())
	var roomId int
	var scene *Scene
	var sp ScenePolicy
	var gamefreeId int32
	var gameSite int32
	var csp *CoinScenePool
	var baseScore int32
	var gps *webapiproto.GameFree

	//根据携带金额取可创房间 DB_Createroom
	arrs := srvdata.PBDB_CreateroomMgr.Datas.Arr
	for i := len(arrs) - 1; i >= 0; i-- {
		if arrs[i].GetGameId() == msg.GetGameId() {
			goldRange := arrs[i].GoldRange
			if len(goldRange) == 0 {
				continue
			}
			if playerTakeCoin >= int64(goldRange[0]) {
				dbCreateRoom = arrs[i]
				break
			}
		}
	}
	if dbCreateRoom == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameFreeId:%v not exist", p.SnId, dbCreateRoom)
		goto failed
	}

	//校验下gameid
	if dbCreateRoom.GetGameId() != gameId {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler PBDB_Createroom Id:%v GameId:%v not exist", dbCreateRoom.GetGameId(), gameId)
		goto failed
	}

	gameSite = dbCreateRoom.GetGameSite()
	gamefreeId = gameId*10000 + gameSite
	gps = PlatformMgrSingleton.GetGameFree(p.Platform, gamefreeId)
	if gps == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameFreeId:%v not exist", p.SnId, gamefreeId)
		goto failed
	}

	dbGameFree = gps.DbGameFree
	//dbGameFree = srvdata.PBDB_GameFreeMgr.GetData(gamefreeId)
	if dbGameFree == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameFreeId:%v not exist", p.SnId, gamefreeId)
		goto failed
	}

	//检测房间状态是否开启
	if !PlatformMgrSingleton.CheckGameState(p.Platform, dbGameFree.Id) {
		code = gamehall.OpResultCode_Game_OPRC_GameHadClosed
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameFreeId:%v GameHadClosed", p.SnId, gamefreeId)
		goto failed
	}

	dbGameRule = srvdata.PBDB_GameRuleMgr.GetData(dbGameFree.GetGameRule())
	if dbGameRule == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameFreeId:%v gamerule not exist", p.SnId, gamefreeId)
		goto failed
	}

	if len(params) == 0 {
		params = common.CopySliceInt32ToInt64(dbGameRule.GetParams())
	}
	sp = GetScenePolicy(int(dbGameFree.GetGameId()), int(dbGameFree.GetGameMode()))
	if sp == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v ScenePolicy(gameid:%v mode:%v) not registe", p.SnId, dbGameFree.GetGameId(), dbGameFree.GetGameMode())
		goto failed
	}

	if p.scene != nil {
		code = gamehall.OpResultCode_Game_OPRC_RoomHadExist_Game
		logger.Logger.Tracef("CSCreateRoomHandler had scene(%d)", p.scene.sceneId)
		goto failed
	}

	//校验底分
	betRange = dbCreateRoom.GetBetRange()
	inRange = false
	for _, bet := range betRange {
		if msg.GetBaseCoin() == bet {
			inRange = true
			break
		}
	}
	if !inRange || msg.GetBaseCoin() == 0 {
		code = gamehall.OpResultCode_Game_OPRC_Error_Game
		logger.Logger.Tracef("CSCreateRoomHandler BaseCoin:%v not in BetRange ", msg.GetBaseCoin())
		goto failed
	}
	//修正底注
	baseScore = msg.GetBaseCoin()

	// 如果人数为0，人数从建房参数中获取，如果没有就用gameconfig中的默认最大人数
	// 再添加新游戏人数放在建房参数params中
	//校验人数
	maxPlayerNum = int(msg.GetMaxPlayerNum())
	if maxPlayerNum != 4 && maxPlayerNum != 2 {
		code = gamehall.OpResultCode_Game_OPRC_Error_Game
		logger.Logger.Tracef("CSCreateRoomHandler GameId_TienLen_maxPlayerNum:%v ", maxPlayerNum)
		maxPlayerNum = 0
	}

	if srvdata.GameFreeMgr.IsGameDif(dbGameFree.GetGameId(), common.GameDifThirteen) {
		switch msg.GetMaxPlayerNum() {
		case 1:
			maxPlayerNum = 8
		default:
			maxPlayerNum = 4
		}
	}

	//创建房间
	csp = CoinSceneMgrSingleton.GetCoinScenePool(p.GetPlatform().IdStr, dbGameFree.GetId())
	roomId = SceneMgrSingleton.GenOneCoinSceneId()
	if roomId == common.RANDID_INVALID {
		code = gamehall.OpResultCode_Game_OPRC_AllocRoomIdFailed_Game
		logger.Logger.Tracef("CSCreateRoomHandler SnId:%v GameId:%v sceneId == -1 ", p.SnId, gameId)
		goto failed
	}

	scene = SceneMgrSingleton.CreateScene(&CreateSceneParam{
		CreateId:  p.SnId,
		RoomId:    roomId,
		SceneMode: int(msg.GetSceneMode()),
		Params:    params,
		Platform:  p.GetPlatform(),
		GF:        dbGameFree,
		PlayerNum: int32(maxPlayerNum),
		BaseScore: baseScore,
	})
	if scene == nil {
		logger.Logger.Tracef("CSCreateRoomHandler CreateScene fail SnId:%v GameId:%v", p.SnId, gameId)
		code = gamehall.OpResultCode_Game_OPRC_Error_Game
		goto failed
	}

	logger.Logger.Tracef("CSCreateRoomHandler SnId:%v Create Sucess GameId:%v", p.SnId, gameId)
	csp.AddScene(scene)
	if !scene.PlayerEnter(p, -1, true) {
		code = gamehall.OpResultCode_Game_OPRC_Error_Game
	}

failed:
	resp := &gamehall.SCCreateRoom{
		GameId:       msg.GetGameId(),
		BaseCoin:     msg.GetBaseCoin(),
		SceneMode:    msg.GetSceneMode(),
		MaxPlayerNum: msg.GetMaxPlayerNum(),
		Params:       msg.GetParams(),
		OpRetCode:    code,
	}
	proto.SetDefaults(resp)
	p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_CREATEROOM), resp)
	return nil
}

// 观众坐下
type CSAudienceSitPacketFactory struct {
}
type CSAudienceSitHandler struct {
}

func (this *CSAudienceSitPacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSAudienceSit{}
	return pack
}

func (this *CSAudienceSitHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSAudienceSitHandler Process recv ", data)
	if msg, ok := data.(*gamehall.CSAudienceSit); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSAudienceSitHandler p == nil")
			return nil
		}
		if p.scene == nil {
			logger.Logger.Warn("CSAudienceSitHandler scene == nil")
			return nil
		}
		if int32(p.scene.sceneId) != msg.GetRoomId() {
			logger.Logger.Warn("CSAudienceSitHandler sceneId != roomId")
			return nil
		}
		newPlayer := PlayerMgrSington.GetPlayerBySnId(p.SnId)
		if newPlayer != nil {
			pack := &gamehall.SCAudienceSit{
				RoomId: proto.Int32(msg.GetRoomId()),
			}
			if !p.scene.IsTestScene() {
				// 入场限额检查
				limitCoin := srvdata.CreateRoomMgrSington.GetLimitCoinByBaseScore(int32(p.scene.gameId), p.scene.dbGameFree.GetSceneType(), p.scene.BaseScore)
				if p.Coin < limitCoin {
					pack.OpCode = gamehall.OpResultCode_Game_OPRC_MoneyNotEnough_Game
					newPlayer.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_AUDIENCESIT), pack)
					return nil
				}
			}
			// 是否还有空座位
			if p.scene.IsFull() {
				pack.OpCode = gamehall.OpResultCode_Game_OPRC_RoomIsFull_Game
				newPlayer.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_AUDIENCESIT), pack)
				return nil
			}
			p.scene.AudienceSit(newPlayer, -1)
			pack.OpCode = gamehall.OpResultCode_Game_OPRC_Sucess_Game
			newPlayer.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_AUDIENCESIT), pack)
		}
	}
	return nil
}

// 我的游戏信息及平台公告
type CSRecordAndNoticePacketFactory struct {
}
type CSRecordAndNoticeHandler struct {
}

func (this *CSRecordAndNoticePacketFactory) CreatePacket() interface{} {
	pack := &gamehall.CSRecordAndNotice{}
	return pack
}

func (this *CSRecordAndNoticeHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRecordAndNoticeHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSRecordAndNotice)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		logger.Logger.Warn("CSRecordAndNoticeHandler p == nil")
		return nil
	}

	pack := &gamehall.SCRecordAndNotice{
		OpCode: gamehall.OpResultCode_Game_OPRC_Sucess_Game,
	}

	switch msg.GetOpt() {
	case 0:
		// 公告
		list := PlatformMgrSingleton.GetCommonNotice(p.Platform)
		if list != nil {
			for _, v := range list.List {
				pack.List = append(pack.List, &gamehall.CommonNotice{
					Sort:          v.Sort,             // 排序 第几位
					Title:         v.Title,            // 标题
					Content:       v.Content,          // 内容
					TypeName:      v.TypeName,         // 大标题
					Type:          v.Type,             // 大标题类型
					StartTime:     int32(v.StartTime), // 开始显示时间
					EndTime:       int32(v.EndTime),   // 结束显示时间
					CategoryType:  v.CategoryType,
					ImgUrl:        v.ImgUrl,
					NoticeId:      v.NoticeId,
					IsLoop:        v.IsLoop,
					LoopTime:      v.LoopTime,
					OnChannelName: v.OnChannelName,
					Url:           v.Url,
				})
			}
		}
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_COMNOTICE), pack)
		logger.Logger.Trace("CSRecordAndNoticeHandler Process send ", pack)

	case 1:
		// 战绩日期列表
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			gdi := model.GetPlayerExistListByTs(p.SnId, p.Platform, msg.StartTime, 7)
			return &gdi
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			if data != nil && data.(*[]int64) != nil {
				gamets := data.(*[]int64)
				pack.GlistTs = append(pack.GlistTs, *gamets...)

			} else {
				pack.OpCode = gamehall.OpResultCode_Game_OPRC_Error_Game
			}
			p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_COMNOTICE), pack)
		}), "SCRecordAndNotice").Start()

	case 2:
		// 当日战绩
		starttime := msg.StartTime
		time := time.Unix(starttime, 0)
		endtime := time.AddDate(0, 0, 1).Unix() - 1 //23:59:59
		var list model.GamePlayerListType
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			list = model.GetPlayerListByHallExAPI(p.SnId, p.Platform, starttime, endtime, int(msg.PageNo), int(msg.PageSize))
			return nil
		}), task.CompleteNotifyWrapper(func(data interface{}, t task.Task) {
			for _, v := range list.Data {
				pack.Glist = append(pack.Glist, &gamehall.PlayerRecord{
					GameFreeid:        v.GameFreeid,
					GameDetailedLogId: v.GameDetailedLogId,
					TotalIn:           v.TotalIn,
					TotalOut:          v.TotalOut,
					Ts:                v.Ts,
					MatchType:         proto.Int32(v.MatchType),
				})
			}
			p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_COMNOTICE), pack)
		}), "SCRecordAndNotice").Start()
	}

	return nil
}

func CSAudienceEnterRoomHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSAudienceEnterRoomHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSEnterRoom)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	var code = gamehall.OpResultCode_Game_OPRC_Error_Game
	var sp ScenePolicy
	var cfg *webapiproto.GameFree

	// 房间是否存在
	scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
	if scene == nil {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Trace("CSAudienceEnterRoomHandler scene == nil")
		goto failed
	}
	// 房间是否正在销毁
	if scene.deleting {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Trace("CSAudienceEnterRoomHandler scene is deleting")
		goto failed
	}
	// 房间是否已经关闭
	if scene.closed {
		code = gamehall.OpResultCode_Game_OPRC_RoomHadClosed_Game
		logger.Logger.Trace("CSAudienceEnterRoomHandler scene is closed")
		goto failed
	}
	// 玩家没有在房间中
	if p.scene != nil {
		code = gamehall.OpResultCode_Game_OPRC_CannotWatchReasonInOther_Game
		logger.Logger.Trace("CSAudienceEnterRoomHandler p.scene != nil")
		goto failed
	}
	// 房间是否可以观战
	if !scene.CanAudience() {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Tracef("CSAudienceEnterRoomHandler scene.CanAudience() %v", scene.sceneId)
		goto failed
	}
	// 比赛场白名单观众
	if scene.IsMatchScene() && !PlatformMgrSingleton.IsMatchAudience(p.Platform, p.SnId) {
		code = gamehall.OpResultCode_Game_OPRC_MatchAudience
		logger.Logger.Tracef("CSAudienceEnterRoomHandler scene.IsMatchAudience() %v", scene.sceneId)
		goto failed
	}
	// 是不是相同平台
	cfg = PlatformMgrSingleton.GetGameFree(p.Platform, scene.dbGameFree.Id)
	if cfg == nil || (scene.platform != nil && scene.platform.Isolated && p.Platform != scene.platform.IdStr) {
		code = gamehall.OpResultCode_Game_OPRC_RoomNotExist_Game
		logger.Logger.Tracef("CSEnterRoomHandler ScenePolicy(gameid:%v mode:%v) scene.platform.Isolated && p.Platform != scene.platform.Name", scene.gameId, scene.gameMode)
		goto failed
	}
	// 游戏规则是否存在
	sp = GetScenePolicy(scene.gameId, scene.gameMode)
	if sp == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameNotExist_Game
		logger.Logger.Tracef("CSAudienceEnterRoomHandler ScenePolicy(gameid:%v mode:%v) not registe", scene.gameId, scene.gameMode)
		goto failed
	}

	switch {
	case scene.IsCoinScene():
		code = gamehall.OpResultCode_Game(CoinSceneMgrSingleton.AudienceEnter(p, cfg.GetDbGameFree().GetId(), msg.GetRoomId(), nil, true))
	case scene.IsHundredScene():

	}

failed:
	if code != gamehall.OpResultCode_Game_OPRC_Sucess_Game {
		resp := &gamehall.SCEnterRoom{
			OpRetCode: code,
		}
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_ENTERROOM), resp)
	}

	return nil
}

func CSRoomConfigHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRoomConfigHandler Process recv ", data)
	_, ok := data.(*gamehall.CSRoomConfig)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	pack := PlatformMgrSingleton.GetRoomConfig(p.Platform, p.LastChannel)
	p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SCRoomConfig), pack)
	logger.Logger.Tracef("SCRoomConfig: %v", pack)
	return nil
}

func CSCreatePrivateRoomHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSCreatePrivateRoomHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSCreatePrivateRoom)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	var needPwd, costType, voice int64
	var password string
	code := gamehall.OpResultCode_Game_OPRC_Error_Game
	pack := &gamehall.SCCreatePrivateRoom{}
	send := func() {
		pack.OpRetCode = code
		p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_CREATEPRIVATEROOM), pack)
		logger.Logger.Tracef("SCCreatePrivateRoom: %v", pack)
	}

	// 参数校验
	cfg := PlatformMgrSingleton.GetConfig(p.Platform).RoomConfig[msg.GetRoomConfigId()]
	if cfg == nil {
		send()
		return nil
	}
	if !slices.Contains(cfg.GetOnChannelName(), p.LastChannel) {
		send()
		return nil
	}

	f := func(param []int32) []int32 {
		if len(param) == 0 {
			return nil
		}
		if param[0] == 0 {
			return param[1:]
		}
		if param[0] > 0 && int(param[0]) < len(param) {
			return []int32{param[param[0]]}
		}
		return nil
	}

	// 场次
	if !slices.Contains(f(cfg.GetGameFreeId()), msg.GetGameFreeId()) {
		send()
		return nil
	}
	// 局数
	if !slices.Contains(f(cfg.GetRound()), msg.GetRound()) {
		send()
		return nil
	}
	// 玩家数量
	if !slices.Contains(f(cfg.GetPlayerNum()), msg.GetPlayerNum()) {
		send()
		return nil
	}
	// 密码
	if cfg.GetNeedPassword() != 3 {
		needPwd = int64(cfg.GetNeedPassword())
	} else {
		needPwd = int64(msg.GetNeedPassword())
	}
	if needPwd < 1 || needPwd > 2 {
		needPwd = 2 // 默认不需要密码
	}
	// 房费类型
	if cfg.GetCostType() != 3 {
		costType = int64(cfg.GetCostType())
	} else {
		costType = int64(msg.GetCostType())
	}
	if costType < 1 || costType > 2 {
		costType = 1 // 默认AA
	}
	// 语音
	if cfg.GetVoice() != 3 {
		voice = int64(cfg.GetVoice())
	} else {
		voice = int64(msg.GetVoice())
	}
	if voice < 1 || voice > 2 {
		voice = 1 // 默认开启语音
	}

	// 场次是否存在
	gf := PlatformMgrSingleton.GetGameFree(p.Platform, msg.GetGameFreeId())
	if gf == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameHadClosed
		send()
		return nil
	}
	sp := GetScenePolicy(int(gf.GetDbGameFree().GetGameId()), int(gf.GetDbGameFree().GetGameMode()))
	if sp == nil {
		code = gamehall.OpResultCode_Game_OPRC_GameHadClosed
		send()
		return nil
	}
	// 游戏是否开启
	if cfg.GetOn() != common.On || !gf.GetStatus() {
		code = gamehall.OpResultCode_Game_OPRC_GameHadClosed
		send()
		return nil
	}
	if p.scene != nil {
		code = gamehall.OpResultCode_Game_OPRC_RoomHadExist_Game
		send()
		return nil
	}

	// 密码
	if needPwd == 1 {
		password = SceneMgrSingleton.GenPassword()
	}

	// 费用是否充足
	if len(cfg.GetCost()) > 0 && !sp.CostEnough(int(costType), int(msg.GetPlayerNum()), cfg, p.SnId) {
		code = gamehall.OpResultCode_Game_OPRC_CostNotEnough
		send()
		return nil
	}

	// 创建房间
	csp := CoinSceneMgrSingleton.GetCoinScenePool(p.GetPlatform().IdStr, msg.GetGameFreeId())
	roomId := SceneMgrSingleton.GenOnePrivateSceneId()
	scene := SceneMgrSingleton.CreateScene(&CreateSceneParam{
		CreateId:   p.SnId,
		RoomId:     roomId,
		SceneMode:  common.SceneModePrivateMatch,
		CycleTimes: 0,
		TotalRound: int(msg.GetRound()),
		Params:     common.CopySliceInt32ToInt64(csp.dbGameRule.GetParams()),
		GS:         nil,
		Platform:   PlatformMgrSingleton.GetPlatform(p.Platform),
		GF:         csp.dbGameFree,
		PlayerNum:  msg.GetPlayerNum(),
		Channel:    cfg.GetOnChannelName(),
		CustomParam: &server.CustomParam{
			RoomTypeId:   cfg.GetRoomType(),
			RoomConfigId: cfg.GetId(),
			CostType:     int32(costType),
			Password:     password,
			Voice:        int32(voice),
			Price:        cfg.GetPrice(),
			ImageURL:     cfg.GetImageURI(),
		},
	})

	if scene == nil {
		code = gamehall.OpResultCode_Game_OPRC_SceneServerMaintain_Game
		send()
		return nil
	}

	csp.AddScene(scene)

	if !scene.PlayerEnter(p, -1, true) {
		send()
		return nil
	}

	if costType == 2 {
		sp.CostPayment(scene, p.SnId)
	}

	code = gamehall.OpResultCode_Game_OPRC_Sucess_Game
	pack = &gamehall.SCCreatePrivateRoom{
		GameFreeId:   msg.GetGameFreeId(),
		RoomTypeId:   msg.GetRoomTypeId(),
		RoomConfigId: msg.GetRoomConfigId(),
		Round:        msg.GetRound(),
		PlayerNum:    msg.GetPlayerNum(),
		NeedPassword: int32(needPwd),
		CostType:     int32(costType),
		Voice:        int32(voice),
		RoomId:       int32(roomId),
		Password:     password,
	}
	send()
	return nil
}

func CSGetPrivateRoomListHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSGetPrivateRoomListHandler Process recv ", data)
	_, ok := data.(*gamehall.CSGetPrivateRoomList)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	PlayerNotifySingle.AddTime(p.SnId, common.NotifyPrivateRoomList, time.Second*15)

	pack := &gamehall.SCGetPrivateRoomList{}
	scenes := SceneMgrSingleton.FindRoomList(&FindRoomParam{
		Platform:    p.Platform,
		GameId:      nil,
		GameMode:    nil,
		SceneMode:   nil,
		RoomId:      0,
		IsCustom:    1,
		IsFree:      0,
		GameFreeId:  nil,
		SnId:        0,
		IsMatch:     false,
		IsRankMatch: false,
		Channel:     []string{p.LastChannel},
	})
	for _, v := range scenes {
		needPassword := 0
		if v.GetPassword() != "" {
			needPassword = 1
		}
		var players []*gamehall.PrivatePlayerInfo
		for _, vv := range v.players {
			players = append(players, &gamehall.PrivatePlayerInfo{
				SnId:      vv.GetSnId(),
				Name:      vv.GetName(),
				UseRoleId: vv.GetRoleId(),
			})
		}
		d := &gamehall.PrivateRoomInfo{
			GameFreeId:   v.dbGameFree.GetId(),
			GameId:       v.dbGameFree.GetGameId(),
			RoomTypeId:   v.GetRoomTypeId(),
			RoomConfigId: v.CustomParam.GetRoomConfigId(),
			RoomId:       int32(v.sceneId),
			NeedPassword: int32(needPassword),
			CurrRound:    v.currRound,
			MaxRound:     v.totalRound,
			CurrNum:      int32(v.GetPlayerCnt()),
			MaxPlayer:    int32(v.playerNum),
			CreateTs:     v.createTime.Unix(),
			State:        v.SceneState,
			Players:      players,
			CostType:     v.CustomParam.GetCostType(),
		}
		if v.CustomWinSnId > 0 {
			p := PlayerMgrSington.GetPlayerBySnId(v.CustomWinSnId)
			if p != nil {
				d.WinSnId = p.SnId
				d.WinName = p.GetName()
				d.WinRoleId = p.Roles.ModId
			}
		}
		if v.creator == 0 {
			d.IsSystem = true
		}
		pack.Datas = append(pack.Datas, d)
	}

	pack.Datas = append(pack.Datas, CustomRoomMgrSingle.GetRoomList(p.Platform)...)

	sort.Slice(pack.Datas, func(i, j int) bool {
		return pack.Datas[i].GetCreateTs() < pack.Datas[j].GetCreateTs()
	})

	p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SC_GETPRIVATEROOMLIST), pack)
	logger.Logger.Tracef("SCGetPrivateRoomList: %v", pack)
	return nil
}

func CSTouchTypeHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSTouchTypeHandler Process recv ", data)
	_, ok := data.(*gamehall.CSTouchType)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	PlayerNotifySingle.AddTime(p.SnId, common.NotifyPrivateRoomList, time.Second*15)

	return nil
}

func CSRoomRecruitHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRoomRecruitHandler Process recv ", data)
	msg, ok := data.(*gamehall.CSRoomRecruit)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()))
	if scene == nil || !scene.IsCustom() || scene.creator != p.SnId {
		return nil
	}

	// 标记招募状态
	scene.IsRecruit = true
	scene.RecruitTimes++

	pack := &gamehall.SCRoomRecruit{
		RoomId: msg.GetRoomId(),
		On:     1,
	}
	p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SCRoomRecruit), pack)
	logger.Logger.Tracef("SCRoomRecruit: %v", pack)
	return nil
}

func CSInviteJoinRoomHandler(s *netlib.Session, packetId int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSInviteJoinRoomHandler Process recv ", data)
	_, ok := data.(*gamehall.CSInviteJoinRoom)
	if !ok {
		return nil
	}

	p := PlayerMgrSington.GetPlayer(sid)
	if p == nil {
		return nil
	}

	pack := &gamehall.SCInviteJoinRoom{}

	scene := SceneMgrSingleton.FindCustomInviteRoom(p)
	if scene != nil {
		pack.RoomId = int32(scene.sceneId)
		pack.IsSystem = scene.creator == 0
		pack.SnId = scene.creator
		if scene.creator > 0 {
			player := PlayerMgrSington.GetPlayerBySnId(scene.creator)
			if player != nil {
				pack.Name = player.GetName()
				pack.UseRoleId = player.Roles.ModId
			}
			cfg := PlatformMgrSingleton.GetConfig(p.Platform).RoomConfig[scene.CustomParam.GetRoomConfigId()]
			if cfg != nil {
				pack.RoomName = cfg.GetName()
			}
		} else {
			cfg := PlatformMgrSingleton.GetConfig(p.Platform).RoomConfig[scene.RoomConfigSystem.GetRoomConfigId()]
			if cfg != nil {
				pack.RoomName = cfg.GetName()
			}
		}
	}

	p.SendToClient(int(gamehall.GameHallPacketID_PACKET_SCInviteJoinRoom), pack)
	logger.Logger.Tracef("SCInviteJoinRoom: %v", pack)
	return nil
}

func init() {
	// 返回房间
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_RETURNROOM), &CSReturnRoomHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_RETURNROOM), &CSReturnRoomPacketFactory{})
	//观众坐下
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_AUDIENCESIT), &CSAudienceSitHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_AUDIENCESIT), &CSAudienceSitPacketFactory{})
	//获取指定游戏配置 包括分场信息
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_GETGAMECONFIG), &CSGetGameConfigHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_GETGAMECONFIG), &CSGetGameConfigPacketFactory{})
	//玩家进入游戏
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_ENTERGAME), &CSEnterGameHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_ENTERGAME), &CSEnterGamePacketFactory{})
	//玩家进入房间
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_ENTERROOM), &CSEnterRoomHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_ENTERROOM), &CSEnterRoomPacketFactory{})
	//玩家退出游戏
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_QUITGAME), &CSQuitGameHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_QUITGAME), &CSQuitGamePacketFactory{})
	//创建房间
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_CREATEROOM), &CSCreateRoomHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_CREATEROOM), &CSCreateRoomPacketFactory{})
	//查询公共房间列表
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_QUERYROOMINFO), &CSQueryRoomInfoHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_QUERYROOMINFO), &CSQueryRoomInfoPacketFactory{})
	//我的游戏信息及平台公告
	common.RegisterHandler(int(gamehall.GameHallPacketID_PACKET_CS_COMNOTICE), &CSRecordAndNoticeHandler{})
	netlib.RegisterFactory(int(gamehall.GameHallPacketID_PACKET_CS_COMNOTICE), &CSRecordAndNoticePacketFactory{})

	// 观众进入房间
	common.Register(int(gamehall.GameHallPacketID_PACKET_CS_AUDIENCE_ENTERROOM), &gamehall.CSEnterRoom{}, CSAudienceEnterRoomHandler)
	// 竞技馆房间配置列表
	common.Register(int(gamehall.GameHallPacketID_PACKET_CSRoomConfig), &gamehall.CSRoomConfig{}, CSRoomConfigHandler)
	// 创建竞技馆房间
	common.Register(int(gamehall.GameHallPacketID_PACKET_CS_CREATEPRIVATEROOM), &gamehall.CSCreatePrivateRoom{}, CSCreatePrivateRoomHandler)
	// 竞技馆房间列表
	common.Register(int(gamehall.GameHallPacketID_PACKET_CS_GETPRIVATEROOMLIST), &gamehall.CSGetPrivateRoomList{}, CSGetPrivateRoomListHandler)
	// 保持刷新
	common.Register(int(gamehall.GameHallPacketID_PACKET_CSTouchType), &gamehall.CSTouchType{}, CSTouchTypeHandler)
	// 设置招募状态
	common.Register(int(gamehall.GameHallPacketID_PACKET_CSRoomRecruit), &gamehall.CSRoomRecruit{}, CSRoomRecruitHandler)
	// 推荐房间
	common.Register(int(gamehall.GameHallPacketID_PACKET_CSInviteJoinRoom), &gamehall.CSInviteJoinRoom{}, CSInviteJoinRoomHandler)
}