package action

import (
	"mongo.games.com/goserver/core/logger"
	"mongo.games.com/goserver/core/netlib"
	"mongo.games.com/goserver/srvlib"

	"mongo.games.com/game/common"
	"mongo.games.com/game/gamesrv/base"
	"mongo.games.com/game/model"
	"mongo.games.com/game/proto"
	"mongo.games.com/game/protocol/server"
	"mongo.games.com/game/protocol/webapi"
)

func HandleWGUpdateSkin(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Trace("receive WGUpdateSkin")
	msg, ok := data.(*server.WGUpdateSkin)
	if !ok {
		return nil
	}
	p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
	if p == nil {
		return nil
	}
	p.Skin.ModId = msg.GetId()
	return nil
}

func HandleWGBuyRecTimeItem(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Trace("receive WGBuyRecTimeItem")
	if msg, ok := data.(*server.WGBuyRecTimeItem); ok {
		p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
		if p != nil {
			p.UpdateBuyRecTimeItem(msg.ExpireTime, msg.Diamond)
		}
	}
	return nil
}

func HandleWGPlayerLeave(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Trace("receive WGPlayerLeaveGame")
	if msg, ok := data.(*server.WGPlayerLeave); ok {
		p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
		if p != nil {
			scene := p.GetScene()
			if scene != nil {
				scene.PlayerLeave(p, common.PlayerLeaveReason_DropLine, false)
			}
		}
	}
	return nil
}

//func HandlePlayerChangeItems(session *netlib.Session, packetId int, data interface{}) error {
//	logger.Logger.Tracef("receive PlayerChangeItems %v", data)
//	msg, ok := data.(*server.PlayerChangeItems)
//	if !ok {
//		return nil
//	}
//	p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
//	if p == nil {
//		return nil
//	}
//	var items []*model.Item
//	for _, v := range msg.GetItems() {
//		items = append(items, &model.Item{
//			ItemId:  v.GetId(),
//			ItemNum: v.GetNum(),
//		})
//	}
//	p.ReceiveAddItems(items)
//	return nil
//}

func CreateSceneHandler(session *netlib.Session, packetId int, data interface{}) error {
	logger.Logger.Tracef("receive CreateScene %v", data)
	msg, ok := data.(*server.WGCreateScene)
	if !ok {
		return nil
	}
	base.SceneMgrSington.CreateScene(&base.CreateSceneParam{
		Session:       session,
		WGCreateScene: msg,
	})
	return nil
}

func init() {
	// 创建房间
	netlib.Register(int(server.SSPacketID_PACKET_WG_CREATESCENE), &server.WGCreateScene{}, CreateSceneHandler)

	//删除场景
	// 立刻删除，不管游戏是否结束
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_DESTROYSCENE), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGDestroyScene{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_DESTROYSCENE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGDestroyScene:", pack)
		msg, ok := pack.(*server.WGDestroyScene)
		if !ok {
			return nil
		}
		if !msg.IsGrace {
			// 立刻删除，不管游戏是否结束
			for _, v := range msg.Ids {
				s := base.SceneMgrSington.GetScene(int(v))
				if s != nil {
					if gameScene, ok := s.ExtraData.(base.GameScene); ok {
						gameScene.SceneDestroy(true)
					}
				}
			}
		} else {
			// 游戏结束后删除房间
			for _, v := range msg.Ids {
				s := base.SceneMgrSington.GetScene(int(v))
				if s != nil {
					if s.IsHundredScene() || s.Gaming {
						s.SetGraceDestroy(true)
					} else {
						if s.IsMatchScene() {
							s.SetGraceDestroy(true)
						}
						if gameScene, ok := s.ExtraData.(base.GameScene); ok {
							gameScene.SceneDestroy(true)
						}
					}
				}
			}
		}

		return nil
	}))

	//玩家进入
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERENTER), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGPlayerEnter{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERENTER), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGPlayerEnter")
		if msg, ok := pack.(*server.WGPlayerEnter); ok {
			sceneId := int(msg.GetSceneId())
			sid := msg.GetSid()
			data := msg.GetPlayerData()
			gateSid := msg.GetGateSid()
			isload := msg.GetIsLoaded()
			IsQM := msg.GetIsQM()
			sendLeave := func(reason int) {
				pack := &server.GWPlayerLeave{
					RoomId:     msg.SceneId,
					PlayerId:   msg.SnId,
					ReturnCoin: msg.TakeCoin,
					Reason:     proto.Int(reason),
				}
				proto.SetDefaults(pack)
				s.Send(int(server.SSPacketID_PACKET_GW_PLAYERLEAVE), pack)
			}
			scene := base.SceneMgrSington.GetScene(sceneId)
			p := base.NewPlayer(sid, data, nil, nil)
			if p == nil && !scene.IsMatchScene() {
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}
			p.UnmarshalIParam(msg.GetIParams())
			p.UnmarshalSParam(msg.GetSParams())
			p.UnmarshalCParam(msg.GetCParams())
			p.AgentCode = msg.GetAgentCode()
			p.Coin = msg.GetTakeCoin()
			p.Pos = int(msg.GetPos())
			p.MatchParams = msg.GetMatchParams()
			for id, num := range msg.Items {
				p.Items[id] = num
			}
			for k, v := range msg.RankScore {
				p.RankScore[k] = v
			}
			p.SetTakeCoin(msg.GetTakeCoin())
			//p.StartCoin = msg.GetTakeCoin()
			//机器人用
			p.ExpectGameTime = msg.GetExpectGameTimes()
			p.ExpectLeaveCoin = msg.GetExpectLeaveCoin()
			//当局游戏结束后剩余金额 起始设置
			p.SetCurrentCoin(msg.GetTakeCoin())

			p.LastSyncCoin = p.Coin
			p.IsQM = IsQM

			if sid == 0 && (scene != nil && !scene.IsMatchScene()) {
				logger.Logger.Warnf("when WGPlayerEnter (sid == 0)")
				//进入房间失败
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}

			if scene == nil {
				logger.Logger.Warn("when WGPlayerEnter (scene == nil)")
				//进入房间失败
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}

			isQuit := p.GetIParam(common.PlayerIParam_IsQuit)
			logger.Logger.Tracef("WGPlayerEnter scene.IsMatchScene()=%v p.GetIParam(common.PlayerIParam_IsQuit)=%v", scene.IsMatchScene(), isQuit)
			if scene.IsMatchScene() && isQuit == 1 { //比赛场退赛
				p.MarkFlag(base.PlayerState_MatchQuit)
				p.MarkFlag(base.PlayerState_Auto)
				p.MarkFlag(base.PlayerState_Leave)
			}

			var sessionId srvlib.SessionId
			sessionId.Set(gateSid)
			gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
			logger.Logger.Tracef("WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), gateSess)
			if gateSess == nil && !scene.IsMatchScene() {
				logger.Logger.Warnf("WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=<nil>", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
				//进入房间失败
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}

			p.SetGateSess(gateSess)
			p.SetWorldSess(s)

			if gateSess != nil {
				pack := &server.GGPlayerSessionBind{
					Sid: proto.Int64(sid),
				}
				if !p.IsRob {
					pack.SnId = proto.Int32(p.SnId)
					pack.Vip = proto.Int32(p.VIP)
					pack.CoinPayTotal = proto.Int64(p.CoinPayTotal)
					pack.Ip = proto.String(p.Ip)
					pack.Platform = proto.String(p.Platform)
				}
				proto.SetDefaults(pack)
				gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
			}

			if scene.Testing {
				p.Coin = int64(scene.GetDBGameFree().GetTestTakeCoin())
			}
			base.PlayerMgrSington.ManagePlayer(p)
			scene.PlayerEnter(p, isload)
			//进场失败
			if p.IsMarkFlag(base.PlayerState_EnterSceneFailed) {
				scene.PlayerLeave(p, common.PlayerLeaveReason_Normal, true)
			} else {
				// 进入成功
				if !p.IsRobot() && !scene.Testing && !scene.IsMatchScene() {
					//base.LogChannelSingleton.WriteMQData(model.GenerateEnterEvent(scene.GetRecordId(), p.SnId, p.Platform,
					//	p.DeviceOS, scene.GameId, scene.GameMode, scene.GetGameFreeId()))
				}
			}
		}
		return nil
	}))

	//观众进入
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_AUDIENCEENTER), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGPlayerEnter{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_AUDIENCEENTER), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive PACKET_WG_AUDIENCEENTER WGPlayerEnter")
		if msg, ok := pack.(*server.WGPlayerEnter); ok {
			sceneId := int(msg.GetSceneId())
			sid := msg.GetSid()
			data := msg.GetPlayerData()
			gateSid := msg.GetGateSid()
			isload := msg.GetIsLoaded()
			IsQM := msg.GetIsQM()
			var sessionId srvlib.SessionId
			sessionId.Set(gateSid)
			sendLeave := func(reason int) {
				pack := &server.GWPlayerLeave{
					RoomId:     msg.SceneId,
					PlayerId:   msg.SnId,
					ReturnCoin: msg.TakeCoin,
					Reason:     proto.Int(reason),
				}
				proto.SetDefaults(pack)
				s.Send(int(server.SSPacketID_PACKET_GW_AUDIENCELEAVE), pack)
			}
			scene := base.SceneMgrSington.GetScene(sceneId)
			if scene == nil || sid == 0 {
				if sid == 0 {
					logger.Logger.Warnf("when WGAUPlayerEnter (sid == 0)")
				}

				//进入房间失败
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}

			gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
			logger.Logger.Tracef("PACKET_WG_AUDIENCEENTER WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), gateSess)
			if gateSess != nil {
				pack := &server.GGPlayerSessionBind{
					Sid: proto.Int64(sid),
				}
				proto.SetDefaults(pack)
				gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
			} else {
				//进入房间失败
				logger.Logger.Warnf("PACKET_WG_AUDIENCEENTER WGPlayerEnter, AreaId=%v, SrvType=%v, SrvId=%v, GateSess=<nil>", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}

			// 自建房检查观众人数上限
			if scene.IsPreCreateScene() {
				if len(scene.GetAudiences()) >= model.GameParamData.MaxAudienceNum {
					sendLeave(common.PlayerLeaveReason_RoomFull)
					return nil
				}
			}

			p := base.PlayerMgrSington.AddPlayer(sid, data, s, gateSess)
			if p == nil {
				//进入房间失败
				sendLeave(common.PlayerLeaveReason_OnDestroy)
				return nil
			}
			p.UnmarshalIParam(msg.GetIParams())
			p.UnmarshalSParam(msg.GetSParams())
			p.UnmarshalCParam(msg.GetCParams())
			p.Coin = msg.GetTakeCoin()
			p.SetTakeCoin(msg.GetTakeCoin())
			p.LastSyncCoin = p.Coin
			p.IsQM = IsQM
			if scene != nil {
				scene.AudienceEnter(p, isload)
				if !p.IsRobot() && !scene.Testing {
					//base.LogChannelSingleton.WriteMQData(model.GenerateEnterEvent(scene.GetRecordId(), p.SnId, p.Platform,
					//	p.DeviceOS, scene.GameId, scene.GameMode, scene.GetGameFreeId()))
				}
			}
		}
		return nil
	}))

	//观众坐下
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_AUDIENCESIT), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGAudienceSit{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_AUDIENCESIT), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive PACKET_WG_AUDIENCESIT WGAudienceSit", pack)
		if msg, ok := pack.(*server.WGAudienceSit); ok {

			p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
			if p != nil {
				scene := p.GetScene()
				if scene != nil {
					p.Pos = int(msg.GetPos())
					//p.coin = msg.GetTakeCoin()
					//p.takeCoin = msg.GetTakeCoin()
					if scene.Testing {
						p.Coin = int64(scene.GetDBGameFree().GetTestTakeCoin())
					}
					p.LastSyncCoin = p.Coin
					scene.AudienceSit(p)
				}
			} else {
				leavePack := &server.GWPlayerLeave{
					RoomId:     msg.SceneId,
					PlayerId:   msg.SnId,
					Reason:     proto.Int(common.PlayerLeaveReason_Bekickout),
					ReturnCoin: msg.TakeCoin,
				}
				proto.SetDefaults(leavePack)
				s.Send(int(server.SSPacketID_PACKET_GW_AUDIENCELEAVE), leavePack)
			}
		}
		return nil
	}))

	//玩家返回房间
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERRETURN), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGPlayerReturn{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERRETURN), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGPlayerReturn")
		if msg, ok := pack.(*server.WGPlayerReturn); ok {
			playerId := msg.GetPlayerId()
			p := base.PlayerMgrSington.GetPlayerBySnId(playerId)
			if p != nil {
				oldFlag := p.GetFlag()
				if !p.IsOnLine() {
					p.MarkFlag(base.PlayerState_Online)
				}
				if p.IsMarkFlag(base.PlayerState_Leave) {
					p.UnmarkFlag(base.PlayerState_Leave)
				}
				if p.GetFlag() != oldFlag {
					p.SyncFlag()
				}
				if p.GetScene() != nil {
					p.GetScene().PlayerReturn(p, msg.GetIsLoaded())
				} else {
					logger.Logger.Warnf("whern (%v) WGPlayerReturn p.scene == nil", playerId)
				}
			} else {
				logger.Logger.Warnf("WGPlayerReturn found player:%v not exist", playerId)
				scene := base.SceneMgrSington.GetScene(int(msg.GetRoomId()))
				if scene != nil {
					p := scene.GetPlayer(msg.GetPlayerId())
					if p != nil {
						logger.Logger.Warnf("WGPlayerReturn found player:%v not exist but in scene:%v gameid:%v", playerId, scene.SceneId, scene.GameId)
					}
				}
				//TODO try leave from room
				pack := &server.GWPlayerForceLeave{
					RoomId:   msg.RoomId,
					PlayerId: msg.PlayerId,
					Reason:   proto.Int(common.PlayerLeaveReason_Bekickout),
					EnterTs:  msg.EnterTs,
				}
				proto.SetDefaults(pack)
				s.Send(int(server.SSPacketID_PACKET_GW_PLAYERFORCELEAVE), pack)
			}
		}
		return nil
	}))

	//玩家掉线
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERDROPLINE), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGPlayerDropLine{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERDROPLINE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGPlayerDropLine:", pack)
		if msg, ok := pack.(*server.WGPlayerDropLine); ok {
			sceneId := int(msg.GetSceneId())
			scene := base.SceneMgrSington.GetScene(sceneId)
			if scene != nil {
				scene.PlayerDropLine(msg.GetId())
			}
		}
		return nil
	}))

	//玩家重连
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_PLAYERREHOLD), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGPlayerRehold{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_PLAYERREHOLD), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGPlayerRehold")
		if msg, ok := pack.(*server.WGPlayerRehold); ok {
			sceneId := int(msg.GetSceneId())
			scene := base.SceneMgrSington.GetScene(sceneId)
			if scene != nil {
				var sessionId srvlib.SessionId
				sessionId.Set(msg.GetGateSid())
				gateSess := srvlib.ServerSessionMgrSington.GetSession(int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()))
				logger.Logger.Tracef("WGPlayerRehold, AreaId=%v, SrvType=%v, SrvId=%v, SessionId=%v", int(sessionId.AreaId()), int(sessionId.SrvType()), int(sessionId.SrvId()), int64(sessionId))
				if gateSess != nil {
					pack := &server.GGPlayerSessionBind{
						Sid: msg.Sid,
					}
					proto.SetDefaults(pack)
					gateSess.Send(int(server.SSPacketID_PACKET_GG_PLAYERSESSIONBIND), pack)
				}
				p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetId())
				if p != nil {
					base.PlayerMgrSington.ReholdPlayer(p.GetSid(), msg.GetSid(), gateSess)
					scene.PlayerRehold(msg.GetId(), msg.GetSid(), gateSess)
				}
			}
		}
		return nil
	}))

	//同步水池设置
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_COINPOOLSETTING), netlib.PacketFactoryWrapper(func() interface{} {
		return &webapi.CoinPoolSetting{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_COINPOOLSETTING), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("CoinPoolSetting Process recv ", pack)
		if wgCoinPoolSetting, ok := pack.(*webapi.CoinPoolSetting); ok {
			base.CoinPoolMgr.UpdateCoinPoolSetting(wgCoinPoolSetting)
			return nil
		}
		return nil
	}))

	// 重置或修改水池水位
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_RESETCOINPOOL), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGResetCoinPool{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_RESETCOINPOOL), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("WGResetCoinPool Process recv ", pack)
		if wgResetCoinPool, ok := pack.(*server.WGResetCoinPool); ok {
			base.CoinPoolMgr.ResetCoinPool(wgResetCoinPool)
			return nil
		}
		return nil
	}))

	//设置玩家黑白名单
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_SETPLAYERBLACKLEVEL), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGSetPlayerBlackLevel{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_SETPLAYERBLACKLEVEL), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("WGSetPlayerBlackLevel Process recv ", pack)
		if wgSetPlayerBlackLevel, ok := pack.(*server.WGSetPlayerBlackLevel); ok {
			p := base.PlayerMgrSington.GetPlayerBySnId(wgSetPlayerBlackLevel.GetSnId())
			if p != nil {
				p.WBLevel = wgSetPlayerBlackLevel.GetWBLevel()
				p.WBCoinLimit = wgSetPlayerBlackLevel.GetWBCoinLimit()
				p.WBMaxNum = wgSetPlayerBlackLevel.GetMaxNum()
				p.WBState = wgSetPlayerBlackLevel.GetState()
				if wgSetPlayerBlackLevel.GetResetTotalCoin() {
					p.WBCoinTotalIn = 0
					p.WBCoinTotalOut = 0
				}
			}
			return nil
		}
		return nil
	}))

	// 修改服务状态
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_SERVER_STATE), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.ServerState{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_SERVER_STATE), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("PACKET_WG_SERVER_STATE Process recv ", pack)
		if srvState, ok := pack.(*server.ServerState); ok {
			base.ServerStateMgr.SetState(common.GameSessState(srvState.GetSrvState()))
			return nil
		}
		return nil
	}))

	//邀请机器人进比赛
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_WG_INVITEMATCHROB), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.WGInviteMatchRob{}
	}))
	netlib.RegisterHandler(int(server.SSPacketID_PACKET_WG_INVITEMATCHROB), netlib.HandlerWrapper(func(s *netlib.Session, packetid int, pack interface{}) error {
		logger.Logger.Trace("receive WGInviteMatchRob:", pack)
		if msg, ok := pack.(*server.WGInviteMatchRob); ok {
			base.NpcServerAgentSingleton.MatchInvite(msg.GetRoomId(), msg.GetMatchId(), msg.GetPlatform(), msg.GetRobNum(), msg.GetNeedAwait())
		}
		return nil
	}))

	//玩家中转消息
	netlib.RegisterFactory(int(server.SSPacketID_PACKET_SS_REDIRECTTOPLAYER), netlib.PacketFactoryWrapper(func() interface{} {
		return &server.SSRedirectToPlayer{}
	}))
	netlib.RegisterHandler(int(server.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.(*server.SSRedirectToPlayer); ok {
			p := base.PlayerMgrSington.GetPlayerBySnId(msg.GetSnId())
			if p == nil {
				logger.Logger.Trace("SSRedirectToPlayer Process recv p == nil ", msg.GetSnId())
				return nil
			}
			p.SendToClient(int(msg.GetPacketId()), msg.GetData())
		}
		return nil
	}))

	common.RegisterMulticastHandler()
	//玩家离开
	netlib.Register(int(server.SSPacketID_PACKET_WG_PlayerLEAVE), server.WGPlayerLeave{}, HandleWGPlayerLeave)
	//同步记牌器过期时间
	netlib.Register(int(server.SSPacketID_PACKET_WG_BUYRECTIMEITEM), server.WGBuyRecTimeItem{}, HandleWGBuyRecTimeItem)
	// 修改皮肤
	netlib.Register(int(server.SSPacketID_PACKET_WG_UpdateSkin), server.WGUpdateSkin{}, HandleWGUpdateSkin)
	// 同步道具数量
	//netlib.Register(int(server.SSPacketID_PACKET_PlayerChangeItems), server.PlayerChangeItems{}, HandlePlayerChangeItems)
}