package main

import (
	"strconv"
	"strings"
	"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/mq"
	loginproto "mongo.games.com/game/protocol/login"
	"mongo.games.com/game/protocol/message"
	playerproto "mongo.games.com/game/protocol/player"
	serverproto "mongo.games.com/game/protocol/server"
	"mongo.games.com/game/srvdata"
)

func init() {
	// 销毁房间
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_DESTROYSCENE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWDestroyScene{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_DESTROYSCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive GWDestroyScene:", pack)
		if msg, ok := pack.(*serverproto.GWDestroyScene); ok {
			SceneMgrSingleton.DestroyScene(int(msg.GetSceneId()), msg.GetIsCompleted())
		}
		return nil
	}))

	// 离开房间
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERLEAVE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWPlayerLeave{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERLEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		//logger.Logger.Trace("receive GWPlayerLeave:", pack)
		msg, ok := pack.(*serverproto.GWPlayerLeave)
		if !ok {
			return nil
		}

		scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
		if scene == nil {
			logger.Logger.Warnf("玩家离开房间，房间没找到 %v", pack)
			return nil
		}

		p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
		if p == nil {
			logger.Logger.Warnf("玩家离开房间，玩家信息没找到 %v", pack)
			return nil
		}

		data := msg.GetPlayerData()
		if len(data) != 0 {
			logger.Logger.Trace("GWPlayerLeave p.UnmarshalData(data)")
			p.UnmarshalData(data, scene)
		}

		switch {
		case scene.IsCoinScene():
			if !CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
				logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v [coinscene]",
					p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
			}
		case scene.IsHundredScene():
			if !HundredSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
				logger.Logger.Warnf("GWPlayerLeave snid:%v sceneid:%v gameid:%v modeid:%v [hundredcene]",
					p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
			}
		default:
			scene.PlayerLeave(p, int(msg.GetReason()))
		}

		if p.scene != nil {
			logger.Logger.Errorf("after GWPlayerLeave found snid:%v sceneid:%v gameid:%v modeid:%v",
				p.SnId, p.scene.sceneId, p.scene.gameId, p.scene.gameMode)
		}

		if scene.IsMatchScene() {
			//结算积分
			if !p.IsRob {
				TournamentMgr.UpdateMatchInfo(p, msg.MatchId, int32(msg.GetReturnCoin()), int32(msg.GetCurIsWin()), msg.GetMatchRobotGrades())
			} else {
				p.matchCtx = nil
			}
		}

		// 同步排位积分
		if scene.IsRankMatch() {
			if p.IsRob {
				RankMgrSingleton.UpdateRobotSeason(p.Platform, p.SnId, scene.dbGameFree.GetRankType(),
					msg.GetRankScore()[scene.dbGameFree.GetRankType()], p.Name, p.Sex, p.HeadUrl, p.Coin, p.PlayerData.GetRoleId())
			} else {
				if model.GameParamData.TestRankMatchAward {
					if RankMgrSingleton.playerSeasons[p.SnId] != nil {
						if RankMgrSingleton.playerSeasons[p.SnId].RankType == nil {
							RankMgrSingleton.playerSeasons[p.SnId].RankType = make(map[int32]*model.PlayerRankInfo)
						}
						if RankMgrSingleton.playerSeasons[p.SnId].RankType[1] == nil {
							RankMgrSingleton.playerSeasons[p.SnId].RankType[1] = &model.PlayerRankInfo{}
						}
						RankMgrSingleton.playerSeasons[p.SnId].RankType[1].LastScore = 7500
						RankMgrSingleton.playerSeasons[p.SnId].RankType[1].Score = 7500
						RankMgrSingleton.playerSeasons[p.SnId].RankType[1].Awards = nil
					}
					RankMgrSingleton.UpdatePlayerSeason(p.SnId, map[int32]int64{1: 10000})
				} else {
					RankMgrSingleton.UpdatePlayerSeason(p.SnId, msg.GetRankScore())
				}

			}
		}
		//更新玩家等级排行榜
		mq.Write(&model.PlayerLevelInfo{
			SnId:     p.SnId,
			Name:     p.Name,
			Level:    p.Level,
			Exp:      p.Exp,
			ModId:    p.PlayerData.GetRoleId(),
			Platform: p.Platform,
		})
		//比赛场不处理下面的内容
		if !scene.IsMatchScene() && !scene.IsCustom() {
			// 破产检测
			sdata := srvdata.PBDB_GameSubsidyMgr.GetData(GameSubsidyid)
			if sdata != nil {
				if !p.IsRob && p.takeCoin > msg.GetReturnCoin() && p.takeCoin >= int64(sdata.LimitNum) && msg.GetReturnCoin() < int64(sdata.LimitNum) {
					CostCoin := p.takeCoin - msg.GetReturnCoin()

					logger.Logger.Infof("NewBankruptLogEx: snid:%v GetReturnCoin:%v coin:%v CostCoin:%v", p.SnId, msg.GetReturnCoin(), p.takeCoin, CostCoin)
					log := model.NewBankruptLogEx(p.SnId, scene.dbGameFree.GetId(), p.CreateTime.Unix(), CostCoin, p.Platform, p.Channel, scene.gameId)
					if log != nil {
						mq.Write(log)
					}
				}
			}
			// 破产检测

			oldCoin := p.Coin

			//带回金币
			if p.Coin != msg.GetReturnCoin() {
				p.Coin = msg.GetReturnCoin()
				if p.Coin < 0 {
					p.Coin = 0
				}

				p.dirty = true
			}

			logger.Logger.Infof("SSPacketID_PACKET_GW_PLAYERLEAVE: snid:%v oldcoin:%v coin:%v", p.SnId, oldCoin, p.Coin)
			p.diffData.Coin = -1                 //强制更新金币
			p.diffData.TotalConvertibleFlow = -1 //强制更新流水
			p.SendDiffData()                     //只是把差异发给前端

			gameCoinTs := msg.GetGameCoinTs()
			if !p.IsRob && !scene.IsTestScene() {
				//对账点同步
				if p.GameCoinTs < gameCoinTs {
					p.GameCoinTs = gameCoinTs
					p.dirty = true
				}

				//破产统计
				//if int(msg.GetReason()) == common.PlayerLeaveReason_Bekickout {
				//	if len(scene.paramsEx) > 0 {
				//		gameIdEx := scene.paramsEx[0]
				//		gps := PlatformMgrSingleton.GetGameFree(scene.platform.IdStr, scene.paramsEx[0])
				//		if gps != nil {
				//			lowLimit := gps.DbGameFree.GetLowerThanKick()
				//			if lowLimit != 0 && p.Coin+p.SafeBoxCoin < int64(lowLimit) {
				//				p.ReportBankRuptcy(int32(scene.gameId), int32(scene.gameMode), gameIdEx)
				//			}
				//		}
				//	}
				//}
			}
		}
		return nil
	}))

	// 观众离开房间
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_AUDIENCELEAVE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWPlayerLeave{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_AUDIENCELEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		//logger.Logger.Trace("receive GWPlayerLeave:", pack)
		if msg, ok := pack.(*serverproto.GWPlayerLeave); ok {
			scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
			if scene != nil {
				p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
				if p != nil {
					gameCoinTs := msg.GetGameCoinTs()
					//带回的金币
					if p.Coin != msg.GetReturnCoin() && !scene.IsMatchScene() {
						p.Coin = msg.GetReturnCoin()
						if p.Coin < 0 {
							p.Coin = 0
						}
						p.dirty = true
					}

					//对账点同步
					if p.GameCoinTs != gameCoinTs {
						p.GameCoinTs = gameCoinTs
						p.dirty = true
					}
					if scene.IsMatchScene() {
						scene.AudienceLeave(p, int(msg.GetReason()))
					} else {
						CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason()))
					}

					//变化金币
					p.dirty = true
					p.diffData.Coin = -1                 //强制更新金币
					p.diffData.TotalConvertibleFlow = -1 //强制更新流水
					p.SendDiffData()
				} else {
					//LocalRobotIdMgrSington.FreeId(msg.GetPlayerId())
				}
			}
		}
		return nil
	}))

	// 房间游戏开始
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_SCENESTART), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWSceneStart{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_SCENESTART), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GW_SCENESTART GWSceneStart:", pack)
		if msg, ok := pack.(*serverproto.GWSceneStart); ok {
			scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
			if scene != nil {
				scene.starting = msg.GetStart()
				scene.currRound = msg.GetCurrRound()
				scene.totalRound = msg.GetMaxRound()
				if scene.starting {
					if scene.currRound == 1 {
						scene.startTime = time.Now()
						//p := PlayerMgrSington.GetPlayer(s.Sid)
					}
				}
				if scene.starting {
					logger.Logger.Trace("游戏开始------", scene.gameId, scene.sceneId, scene.replayCode, scene.currRound)
				} else {
					logger.Logger.Trace("游戏结束------", scene.gameId, scene.sceneId, scene.replayCode, scene.currRound)
				}
			}
		}
		return nil
	}))

	// 房间游戏状态
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_SCENESTATE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWSceneState{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_SCENESTATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GW_SCENESTATE GWSceneState:", pack)
		if msg, ok := pack.(*serverproto.GWSceneState); ok {
			scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
			if scene != nil {
				scene.sp.OnSceneState(scene, int(msg.GetRoomState()))
			}
		}
		return nil
	}))

	// 用户状态同步 flag
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERSTATE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWPlayerFlag{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERSTATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive GWPlayerFlag:", pack)
		if msg, ok := pack.(*serverproto.GWPlayerFlag); ok {
			player := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
			if player != nil {
				player.flag = msg.GetFlag()
			}
		}
		return nil
	}))

	// 房间服务器状态切换
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GB_STATE_SWITCH), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.ServerStateSwitch{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GB_STATE_SWITCH), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GB_STATE_SWITCH ServerStateSwitch:", pack)
		if sr, ok := pack.(*serverproto.ServerStateSwitch); ok {
			srvid := int(sr.GetSrvId())
			gameSess := GameSessMgrSington.GetGameSess(srvid)
			if gameSess != nil {
				if gameSess.state == common.GameSessStateOn {
					gameSess.SwitchState(common.GameSessStateOff)
				} else {
					gameSess.SwitchState(common.GameSessStateOn)
				}
			} else {
				gateSess := GameSessMgrSington.GetGateSess(srvid)
				if gateSess != nil {
					if gateSess.state == common.GameSessStateOn {
						gateSess.SwitchState(common.GameSessStateOff)
					} else {
						gateSess.SwitchState(common.GameSessStateOn)
					}
				}
			}
		}
		return nil
	}))

	// 游戏服务器的系统广播
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_NEWNOTICE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWNewNotice{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_NEWNOTICE), netlib.HandlerWrapper(func(s *netlib.Session, packetID int, pack interface{}) error {
		logger.Logger.Tracef("receive SSPacketID_PACKET_GW_NEWNOTICE GWNewNotice:%v", pack)
		msg, ok := pack.(*serverproto.GWNewNotice)
		if !ok {
			return nil
		}

		switch msg.GetTp() {
		case common.NoticeTypeCustomAward:
			var items []*message.Item
			for _, v := range msg.GetItems() {
				items = append(items, &message.Item{
					Id:  v.GetId(),
					Num: v.GetNum(),
				})
			}
			notice := &message.Notice{
				Tp:     msg.GetTp(),
				SnId:   msg.GetSnId(),
				Name:   msg.GetName(),
				RoleId: msg.GetRoleId(),
				Items:  items,
			}
			PlayerMgrSington.BroadcastMessageToPlatform(msg.GetPlatform(), int(message.MSGPacketID_PACKET_Notice), notice)
			logger.Logger.Tracef("broadcast custom award notice:%v", notice)

			// 更新房间获奖信息
			scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
			if scene != nil {
				scene.CustomWinSnId = msg.SnId
			}

		default:
			logger.Logger.Errorf("not type GWNewNotice:%v", pack)
		}

		return nil
	}))

	// 强制离开房间
	// 返回房间失败
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWPlayerForceLeave{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		if msg, ok := pack.(*serverproto.GWPlayerForceLeave); ok {
			logger.Logger.Warn("receive GWPlayerForceLeave:", msg)
			scene := SceneMgrSingleton.GetScene(int(msg.GetRoomId()), true)
			if scene != nil {
				p := PlayerMgrSington.GetPlayerBySnId(msg.GetPlayerId())
				if p != nil {
					ctx := scene.GetPlayerGameCtx(p.SnId)
					if ctx != nil && p.scene == scene && scene.HasPlayer(p) && ctx.enterTs == msg.GetEnterTs() {
						switch {
						case scene.IsCoinScene():
							if !CoinSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
								logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v [coinscene]", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
							}
						case scene.IsHundredScene():
							if !HundredSceneMgrSingleton.PlayerLeave(p, int(msg.GetReason())) {
								logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v [hundredcene]", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
							}
						default:
							scene.PlayerLeave(p, int(msg.GetReason()))
						}

						if p.scene != nil {
							logger.Logger.Warnf("after GWPlayerForceLeave found snid:%v sceneid:%v gameid:%v modeid:%v", p.SnId, p.scene.sceneId, p.scene.gameId, p.scene.gameMode)
							p.scene.PlayerLeave(p, int(msg.GetReason()))
						}
					} else {
						logger.Logger.Warnf("GWPlayerForceLeave snid:%v sceneid:%v gameid:%v modeid:%v fount not p.scene==scene && scene.HasPlayer(p)", p.SnId, scene.sceneId, scene.gameId, scene.gameMode)
					}
				}
			} else {
				logger.Logger.Warnf("GWPlayerForceLeave snid:%v scene:%v had closed", msg.GetPlayerId(), msg.GetRoomId())
			}
		}
		return nil
	}))

	//一局游戏一结算
	//可处理以下业务
	//1.同步玩家游戏场内的实时金币
	//2.触发相关任务:统计有效下注金币数,赢取金币数,牌局次数等
	//3.黑名单处理
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_PLAYERDATA), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWPlayerData{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_PLAYERDATA), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive GWPlayerBet:", pack)
		if msg, ok := pack.(*serverproto.GWPlayerData); ok {
			scene := SceneMgrSingleton.GetScene(int(msg.GetSceneId()), true)
			if scene == nil {
				return nil
			}
			for _, playerBet := range msg.GetDatas() {
				player := PlayerMgrSington.GetPlayerBySnId(playerBet.GetSnId())
				if player != nil && !player.IsRob {
					// task 赢次数
					if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
						TaskSubjectSingleton.Touch(common.TaskTypeWinTimes, &TaskData{
							SnId:       player.SnId,
							GameID:     scene.gameId,
							GameFreeID: scene.dbGameFree.GetId(),
							Num:        1,
						})
						if scene.IsRankMatch() {
							TaskSubjectSingleton.Touch(common.TaskTypeRankMatchWinTimes, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        1,
							})
						}
						// 大众场
						if common.IsDaZhong(scene.gameId) {
							TaskSubjectSingleton.Touch(common.TaskTypeDaZhong, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        1,
							})
						}
					}
					// task 游戏局数
					TaskSubjectSingleton.Touch(common.TaskTypePlayTimes, &TaskData{
						SnId:       player.SnId,
						GameID:     scene.gameId,
						GameFreeID: scene.dbGameFree.GetId(),
						Num:        1,
					})
					// task 排位赛次数
					if scene.IsRankMatch() {
						TaskSubjectSingleton.Touch(common.TaskTypeRankMatchTimes, &TaskData{
							SnId:       player.SnId,
							GameID:     scene.gameId,
							GameFreeID: scene.dbGameFree.GetId(),
							Num:        1,
						})
					}
					if !scene.IsMatchScene() { // 比赛没金币是积分
						n := playerBet.GetGain()
						if n < 0 {
							n = -n
						}
						//游戏中输赢金币
						TaskSubjectSingleton.Touch(common.TaskTypeWinOrLose, &TaskData{
							SnId:       player.SnId,
							GameID:     scene.gameId,
							GameFreeID: scene.dbGameFree.GetId(),
							Num:        n,
						})
						// 游戏中赢金币
						if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
							TaskSubjectSingleton.Touch(common.TaskTypeWinCoin, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        playerBet.GetGain(),
							})
						}
						if playerBet.GetGain() < 0 && playerBet.WinState != 1 {
							TaskSubjectSingleton.Touch(common.TaskTypeLoseCoin, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        playerBet.GetGain(),
							})
						}
					}
					//tienlen 游戏场次
					if scene.dbGameFree.GameDif == common.GameDifTienlen {
						TaskSubjectSingleton.Touch(common.TaskTypeTienlenCount, &TaskData{
							SnId:       player.SnId,
							GameID:     scene.gameId,
							GameFreeID: scene.dbGameFree.GetId(),
							Num:        1,
						})
						//tienlen 游戏输的金币
						if playerBet.GetGain() < 0 && playerBet.WinState != 1 {
							TaskSubjectSingleton.Touch(common.TaskTypeTienlenLoseCoin, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        playerBet.GetGain(),
							})
						}
						// tienlen游戏中赢金币
						if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
							TaskSubjectSingleton.Touch(common.TaskTypeTienlenWinCoin, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        playerBet.GetGain(),
							})
						}
						if playerBet.GetGain() > 0 || playerBet.WinState == 1 {
							TaskSubjectSingleton.Touch(common.TaskTypeTienlenWinTimes, &TaskData{
								SnId:       player.SnId,
								GameID:     scene.gameId,
								GameFreeID: scene.dbGameFree.GetId(),
								Num:        1,
							})
						}
					}

					if !scene.IsMatchScene() && !scene.IsCustom() { // 比赛没金币是积分
						player.Coin = playerBet.GetCoin()
						player.GameCoinTs = playerBet.GetGameCoinTs()
						player.GameTax += playerBet.GetTax()
						player.dirty = true
						player.WBUpdate(playerBet.GetWBGain())
					}
				}
			}
		}
		return nil
	}))

	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_JACKPOTLIST), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWGameJackList{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_JACKPOTLIST), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GW_JACKPOTLIST GWGameJackList:", pack)
		if msg, ok := pack.(*serverproto.GWGameJackList); ok {
			FishJackListMgr.Insert(msg.GetCoin(), msg.GetSnId(), msg.GetRoomId(), msg.GetJackType(), msg.GetGameId(),
				msg.GetPlatform(), msg.GetChannel(), msg.GetName())
		}
		return nil
	}))

	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_JACKPOTCOIN), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWGameJackCoin{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_JACKPOTCOIN), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GW_JACKPOTCOIN GWGameJackCoin:", pack)
		if msg, ok := pack.(*serverproto.GWGameJackCoin); ok {
			for i, pl := range msg.Platform {
				FishJackpotCoinMgr.Jackpot[pl] = msg.Coin[i]
			}
		}
		return nil
	}))

	//强制换桌
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_GW_CHANGESCENEEVENT), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.GWChangeSceneEvent{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_GW_CHANGESCENEEVENT), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive SSPacketID_PACKET_GW_CHANGESCENEEVENT GWChangeSceneEvent:", pack)
		if msg, ok := pack.(*serverproto.GWChangeSceneEvent); ok {
			scene := SceneMgrSingleton.GetScene(int(msg.GetSceneId()))
			if scene != nil {
				//scene.PlayerTryChange()
			}
		}
		return nil
	}))

	//玩家中转消息
	netlib.RegisterFactory(int(serverproto.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.PacketFactoryWrapper(func() interface{} {
		return &serverproto.SSRedirectToPlayer{}
	}))
	netlib.RegisterHandler(int(serverproto.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.HandlerWrapper(func(s *netlib.Session,
		packetid int, pack interface{}) error {
		logger.Logger.Trace("SSRedirectToPlayer Process recv ", pack)
		if msg, ok := pack.(*serverproto.SSRedirectToPlayer); ok {
			p := PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
			if p == nil {
				return nil
			}
			p.SendToClient(int(msg.GetPacketId()), msg.GetData())
		}
		return nil
	}))
}

// 机器人服务器向worldsrv发送
type CSPMCmdPacketFactory struct {
}
type CSPMCmdHandler struct {
}

func (this *CSPMCmdPacketFactory) CreatePacket() interface{} {
	pack := &playerproto.CSPMCmd{}
	return pack
}

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

		if !p.IsRob && p.GMLevel < 3 {
			logger.Logger.Trace("CSPMCmdHandler p.Channel != common.Channel_Rob && p.GMLevel < 3")
			return nil
		}

		cmd := msg.GetCmd()
		logger.Logger.Infof("CSPMCmdHandler %v %v", p.SnId, cmd)
		args := strings.Split(cmd, common.PMCmd_SplitToken)
		argsCnt := len(args)
		if argsCnt != 0 {
			switch args[0] {
			case common.PMCmd_AddCoin:
				if argsCnt > 1 {
					coin, err := strconv.ParseInt(args[1], 10, 64) //strconv.Atoi(args[1])
					if err != nil {
						logger.Logger.Warnf("CSPMCmdHandler %v parse %v err:%v", p.SnId, cmd, err)
						return nil
					}
					if coin != 0 {
						p.CoinPayTotal += int64(coin)
						p.dirty = true
						p.AddCoin(coin, 0, common.GainWay_ByPMCmd, p.GetName(), cmd)
						p.SendDiffData()
					}
				}
			case common.PMCmd_Privilege:

			}
		}
	}
	return nil
}

type CSRobotChgDataPacketFactory struct {
}
type CSRobotChgDataHandler struct {
}

func (this *CSRobotChgDataPacketFactory) CreatePacket() interface{} {
	pack := &playerproto.CSRobotChgData{}
	return pack
}

func (this *CSRobotChgDataHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSRobotChgDataHandler Process recv ", data)
	if _, ok := data.(*playerproto.CSRobotChgData); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Trace("CSRobotChgDataHandler p == nil")
			return nil
		}

		if !p.IsRob {
			logger.Logger.Trace("CSRobotChgDataHandler !p.IsRob")
			return nil
		}
	}
	return nil
}

type CSAccountInvalidPacketFactory struct {
}
type CSAccountInvalidHandler struct {
}

func (this *CSAccountInvalidPacketFactory) CreatePacket() interface{} {
	pack := &loginproto.CSAccountInvalid{}
	return pack
}

func (this *CSAccountInvalidHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSAccountInvalidHandler Process recv ", data)
	if _, ok := data.(*loginproto.CSAccountInvalid); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p != nil && p.IsRobot() {
			snid := p.SnId
			acc := p.AccountId
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				err := model.RemoveAccount(p.Platform, acc)
				if err != nil {
					logger.Logger.Error("Remove robot account data error:", err)
				}
				err = model.RemovePlayerByAcc(p.Platform, acc)
				if err != nil {
					logger.Logger.Error("Remove robot player data error:", err)
				}
				logger.Logger.Trace("CSAccountInvalid message remove :", acc)
				return nil
			}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
				PlayerMgrSington.DelPlayer(snid)
				LoginStateMgrSington.DelAccountByAccid(acc)
				return
			}), "RemoveAccount").StartByFixExecutor("RemoveAccount")
		}
	}
	return nil
}

func init() {
	common.RegisterHandler(int(playerproto.PlayerPacketID_PACKET_CS_PMCMD), &CSPMCmdHandler{})
	netlib.RegisterFactory(int(playerproto.PlayerPacketID_PACKET_CS_PMCMD), &CSPMCmdPacketFactory{})

	common.RegisterHandler(int(playerproto.PlayerPacketID_PACKET_CS_ROBOTCHGDATA), &CSRobotChgDataHandler{})
	netlib.RegisterFactory(int(playerproto.PlayerPacketID_PACKET_CS_ROBOTCHGDATA), &CSRobotChgDataPacketFactory{})

	common.RegisterHandler(int(loginproto.LoginPacketID_PACKET_CS_ACCOUNTINVALID), &CSAccountInvalidHandler{})
	netlib.RegisterFactory(int(loginproto.LoginPacketID_PACKET_CS_ACCOUNTINVALID), &CSAccountInvalidPacketFactory{})
}

func init() {
	// 同步道具数量
	netlib.Register(int(serverproto.SSPacketID_PACKET_PlayerChangeItems), &serverproto.PlayerChangeItems{}, HandlePlayerChangeItems)
}

func HandlePlayerChangeItems(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("HandlePlayerChangeItems recv %v", data)
	msg, ok := data.(*serverproto.PlayerChangeItems)
	if !ok {
		return nil
	}
	param := model.AddItemParam{}
	if err := netlib.Gob.Unmarshal(msg.GetData(), &param); err != nil {
		logger.Logger.Errorf("HandlePlayerChangeItems 游戏道具变更同步失败 %v", err)
		return err
	}
	p := PlayerMgrSington.GetPlayerBySnId(param.SnId)
	if p == nil {
		logger.Logger.Errorf("HandlePlayerChangeItems player is nil")
		return nil
	}
	_, _, ok = BagMgrSingleton.AddItems(&param)
	if !ok {
		logger.Logger.Errorf("HandlePlayerChangeItems add item failed %+v", param)
	}
	return nil
}