package main

import (
	"strconv"
	"strings"
	"time"
	"unicode/utf8"

	"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/friend"
	"mongo.games.com/game/srvdata"
)

type CSFriendListPacketFactory struct {
}

type CSFriendListHandler struct {
}

func (this *CSFriendListPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSFriendList{}
	return pack
}

func (this *CSFriendListHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSFriendListHandler Process recv ", data)
	if msg, ok := data.(*friend.CSFriendList); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSFriendListHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		pack := &friend.SCFriendList{
			ListType:  proto.Int32(msg.GetListType()),
			OpRetCode: friend.OpResultCode_OPRC_Sucess,
		}
		switch msg.GetListType() {
		case ListType_Friend:
			dfl := FriendMgrSington.GetFriendList(p.Platform, p.GetSnId())
			if dfl != nil {
				for _, bf := range dfl {
					if bf.SnId == p.SnId {
						continue
					}
					fi := &friend.FriendInfo{
						SnId:       proto.Int32(bf.SnId),
						Name:       proto.String(bf.Name),
						Sex:        proto.Int32(bf.Sex),
						Head:       proto.Int32(bf.Head),
						HeadUrl:    proto.String(bf.HeadUrl),
						CreateTs:   proto.Int64(bf.CreateTime),
						LogoutTs:   proto.Int64(bf.LogoutTime),
						LastChatTs: proto.Int64(bf.CreateTime),
						IsShield:   proto.Bool(FriendMgrSington.IsShield(p.Platform, p.SnId, bf.SnId)),
						RoleId:     bf.RoleId,
					}
					fi.Online = false
					bfp := PlayerMgrSington.GetPlayerBySnId(bf.SnId)
					if bfp != nil {
						fi.Online = bfp.IsOnLine()
					}
					chat := ChatMgrSington.GetChat(p.Platform, p.SnId, bf.SnId)
					if chat != nil {
						fi.LastChatTs = chat.LastChatTs
					}
					pack.FriendArr = append(pack.FriendArr, fi)
				}
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(friend.FriendPacketID_PACKET_SCFriendList), pack)
			logger.Logger.Trace("SCFriendListHandler:", pack)
		case ListType_Apply:
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				ret, err := model.QueryFriendApplyBySnid(p.Platform, p.SnId)
				if err != nil {
					return nil
				}
				return ret
			}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
				if ret, ok := data.(*model.FriendApply); ok && ret != nil && ret.ApplySnids != nil {
					for _, as := range ret.ApplySnids {
						if as.SnId == p.SnId {
							continue
						}
						fi := &friend.FriendInfo{
							SnId:     proto.Int32(as.SnId),
							Name:     proto.String(as.Name),
							Head:     proto.Int32(as.Head),
							HeadUrl:  proto.String(as.HeadUrl),
							CreateTs: proto.Int64(as.CreateTs),
							RoleId:   as.RoleId,
						}
						fi.Online = false
						bfp := PlayerMgrSington.GetPlayerBySnId(as.SnId)
						if bfp != nil {
							fi.Online = bfp.IsOnLine()
						}
						pack.FriendArr = append(pack.FriendArr, fi)
					}
				}
				proto.SetDefaults(pack)
				p.SendToClient(int(friend.FriendPacketID_PACKET_SCFriendList), pack)
				logger.Logger.Trace("SCFriendListHandler: ", pack)
			})).Start()
		case ListType_Recommend:
			friends := PlayerMgrSington.RecommendFriendRule(p.Platform, p.SnId)
			for _, f := range friends {
				if f.Snid == p.SnId {
					continue
				}
				fi := &friend.FriendInfo{
					SnId:    proto.Int32(f.Snid),
					Name:    proto.String(f.Name),
					Head:    proto.Int32(f.Head),
					HeadUrl: proto.String(f.HeadUrl),
					RoleId:  f.RoleId,
				}
				pack.FriendArr = append(pack.FriendArr, fi)
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(friend.FriendPacketID_PACKET_SCFriendList), pack)
			logger.Logger.Trace("SCFriendListHandler: ", pack)
		}
	}
	return nil
}

type CSFriendOpPacketFactory struct {
}

type CSFriendOpHandler struct {
}

func (this *CSFriendOpPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSFriendOp{}
	return pack
}

func (this *CSFriendOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSFriendOpHandler Process recv ", data)
	if msg, ok := data.(*friend.CSFriendOp); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSFriendOpHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			return nil
		}
		destP := PlayerMgrSington.GetPlayerBySnId(msg.SnId)
		if destP != nil {
			roleId := common.DefaultRoleId
			if destP.Roles != nil {
				roleId = int(destP.Roles.ModId)
			}
			FriendMgrSington.FriendOp(msg.OpCode, p, &model.BindFriend{
				SnId:       destP.SnId,
				Platform:   destP.Platform,
				Name:       destP.Name,
				Head:       destP.Head,
				HeadUrl:    destP.HeadUrl,
				Sex:        destP.Sex,
				LogoutTime: destP.LastLogoutTime.Unix(),
				CreateTime: time.Now().Unix(),
				RoleId:     int32(roleId),
			})
		} else {
			task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
				return model.GetPlayerBaseInfo(p.Platform, msg.SnId)
			}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
				if data == nil {
					pack := &friend.SCFriendOp{
						OpCode:    proto.Int32(msg.OpCode),
						SnId:      proto.Int32(msg.SnId),
						OpRetCode: friend.OpResultCode_OPRC_Error,
					}
					p.SendToClient(int(friend.FriendPacketID_PACKET_SCFriendOp), pack)
					return
				}
				if destPlayer, ok := data.(*model.PlayerBaseInfo); ok && destPlayer != nil {
					roleId := common.DefaultRoleId
					if destPlayer.Roles != nil {
						roleId = int(destPlayer.Roles.ModId)
					}
					FriendMgrSington.FriendOp(msg.OpCode, p, &model.BindFriend{
						SnId:       destPlayer.SnId,
						Platform:   destPlayer.Platform,
						Name:       destPlayer.Name,
						Head:       destPlayer.Head,
						HeadUrl:    destPlayer.HeadUrl,
						Sex:        destPlayer.Sex,
						LogoutTime: destPlayer.LastLogoutTime.Unix(),
						CreateTime: time.Now().Unix(),
						RoleId:     int32(roleId),
					})
				}
			})).Start()
		}
	}
	return nil
}

type CSQueryPlayerGameLogPacketFactory struct {
}
type CSQueryPlayerGameLogHandler struct {
}

func (this *CSQueryPlayerGameLogPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSQueryPlayerGameLog{}
	return pack
}

func (this *CSQueryPlayerGameLogHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSQueryPlayerGameLogHandler Process recv ", data)
	if msg, ok := data.(*friend.CSQueryPlayerGameLog); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSQueryPlayerGameLogHandler p == nil")
			return nil
		}
		snid := msg.GetSnid()
		gameId := msg.GetGameId()
		size := msg.GetSize()

		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			ret := model.GetFriendRecordLogBySnid(p.Platform, snid, gameId, int(size))
			return ret
		}), task.CompleteNotifyWrapper(func(data interface{}, tt task.Task) {
			pack := &friend.SCQueryPlayerGameLog{
				Snid:   snid,
				GameId: gameId,
				Size:   size,
			}
			if ret, ok := data.([]*model.FriendRecord); ok && ret != nil {
				for _, gpl := range ret {
					gl := &friend.PlayerGameLog{
						GameId:    proto.Int32(gpl.GameId),
						BaseScore: proto.Int32(gpl.BaseScore),
						IsWin:     proto.Int32(gpl.IsWin),
						Ts:        proto.Int64(gpl.Ts),
						BillCoin:  proto.Int64(gpl.BillCoin),
						MatchType: proto.Int32(int32(gpl.MatchType)),
					}
					pack.GameLogs = append(pack.GameLogs, gl)
				}
			}
			proto.SetDefaults(pack)
			p.SendToClient(int(friend.FriendPacketID_PACKET_SCQueryPlayerGameLog), pack)
			logger.Logger.Trace("SCQueryPlayerGameLogHandler: ", pack)
		})).Start()
	}
	return nil
}

type CSInviteFriendPacketFactory struct {
}

type CSInviteFriendHandler struct {
}

func (this *CSInviteFriendPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSInviteFriend{}
	return pack
}

func (this *CSInviteFriendHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSInviteFriendHandler Process recv ", data)
	if msg, ok := data.(*friend.CSInviteFriend); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSInviteFriendHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			logger.Logger.Warn("CSInviteFriendHandler platform == nil")
			return nil
		}
		friendSnid := msg.GetToSnId()
		var opRetCode = friend.OpResultCode_OPRC_Sucess
		send := func(player *Player) {
			roleId := common.DefaultRoleId
			if p.Roles != nil {
				roleId = int(p.Roles.ModId)
			}
			pack := &friend.SCInviteFriend{
				SrcSnId:    proto.Int32(p.SnId),
				SrcName:    proto.String(p.Name),
				SrcHead:    proto.Int32(p.Head),
				SrcHeadUrl: proto.String(p.HeadUrl),
				OpRetCode:  opRetCode,
				GameId:     proto.Int(p.scene.gameId),
				RoomId:     proto.Int(p.scene.sceneId),
				Pos:        proto.Int32(msg.GetPos()),
				RoleId:     int32(roleId),
			}
			proto.SetDefaults(pack)
			player.SendToClient(int(friend.FriendPacketID_PACKET_SCInviteFriend), pack)
			logger.Logger.Trace("SCInviteFriendHandler: ", pack)

			// 记录邀请记录
			if opRetCode == friend.OpResultCode_OPRC_Sucess {
				if p.SnId != player.SnId {
					p.TaskInviteList[player.SnId] = p.scene.sceneId
				}
			}
		}
		//不能邀请自己
		if p.SnId == friendSnid {
			logger.Logger.Warn("CSInviteFriendHandler invite self")
			opRetCode = friend.OpResultCode_OPRC_Friend_NotOpMyself
			send(p)
			return nil
		}
		//不是好友
		if !FriendMgrSington.IsFriend(p.Platform, p.SnId, friendSnid) {
			logger.Logger.Warn("CSInviteFriendHandler not friend")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_NotFriend
			send(p)
			return nil
		}
		fp := PlayerMgrSington.GetPlayerBySnId(friendSnid)
		//不在线
		if fp == nil || !fp.IsOnLine() {
			logger.Logger.Warn("CSInviteFriendHandler not online")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_NoOnline
			send(p)
			return nil
		}
		//CD
		if !FriendMgrSington.CanInvite(p.Platform, p.SnId, friendSnid) {
			logger.Logger.Warn("CSInviteFriendHandler in cd time")
			opRetCode = friend.OpResultCode_OPRC_Error
			send(p)
			return nil
		}
		//scene
		if p.scene == nil {
			logger.Logger.Warn("CSInviteFriendHandler scene is nil")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_SceneNotExist
			send(p)
			return nil
		}
		//私有房间
		if p.scene.sceneMode != common.SceneMode_Private {
			logger.Logger.Warn("CSInviteFriendHandler scene is common.SceneMode_Private")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_RoomLimit
			send(p)
			return nil
		}
		//好友已在游戏中
		if fp.scene != nil {
			logger.Logger.Warn("CSInviteFriendHandler scene is common.SceneMode_Private")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_Gaming
			send(p)
			return nil
		}
		pos := int(msg.GetPos())
		if pos < 0 || pos >= p.scene.playerNum {
			logger.Logger.Trace("CSInviteFriendHandler pos is fail")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_PosIsError //座位不存在
			send(p)
			return nil
		}
		if opRetCode == friend.OpResultCode_OPRC_Sucess { //成功都通知下
			send(p)
			send(fp)
		}
	}
	return nil
}

type CSInviteFriendOpPacketFactory struct {
}

type CSInviteFriendOpHandler struct {
}

func (this *CSInviteFriendOpPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSInviteFriendOp{}
	return pack
}

func (this *CSInviteFriendOpHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSInviteFriendOpHandler Process recv ", data)
	if msg, ok := data.(*friend.CSInviteFriendOp); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSInviteFriendOpHandler p == nil")
			return nil
		}
		platform := p.GetPlatform()
		if platform == nil {
			logger.Logger.Warn("CSInviteFriendOpHandler platform == nil")
			return nil
		}
		srcSnid := msg.GetSnId()
		opcode := msg.GetOpCode()
		var opRetCode = friend.OpResultCode_OPRC_Sucess
		send := func(player *Player) {
			pack := &friend.SCInviteFriendOp{
				SnId:      proto.Int32(p.SnId),
				Name:      proto.String(p.Name),
				OpCode:    proto.Int32(opcode),
				OpRetCode: opRetCode,
				Pos:       proto.Int32(msg.GetPos()),
			}
			proto.SetDefaults(pack)
			isok := player.SendToClient(int(friend.FriendPacketID_PACKET_SCInviteFriendOp), pack)
			logger.Logger.Trace("SCInviteFriendOpHandler isok: ", isok, " pack: ", pack)
		}
		fp := PlayerMgrSington.GetPlayerBySnId(srcSnid)
		//不能操作自己
		if p.SnId == srcSnid {
			logger.Logger.Warn("CSInviteFriendHandler invite self")
			opRetCode = friend.OpResultCode_OPRC_Friend_NotOpMyself
			send(p)
			return nil
		}
		//不在线
		if fp == nil || !fp.IsOnLine() {
			logger.Logger.Warn("CSInviteFriendHandler not online")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_NoOnline
			send(p)
			return nil
		}
		//不是好友
		if !FriendMgrSington.IsFriend(p.Platform, p.SnId, srcSnid) {
			logger.Logger.Warn("CSInviteFriendHandler not friend")
			opRetCode = friend.OpResultCode_OPRC_InviteFriend_NotFriend
			send(p)
			return nil
		}

		switch int(opcode) {
		case Invite_Agree:
			logger.Logger.Trace("同意邀请")
			if p.scene != nil {
				logger.Logger.Warn("CSInviteFriendHandler scene is not nil")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_HadInRoom //已在房间中
				send(p)
				return nil
			}
			scene := fp.scene
			if scene == nil {
				logger.Logger.Warn("CSInviteFriendHandler scene is nil")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_SceneNotExist //场景不存在
				send(p)
				return nil
			}
			//私有房间
			if scene.sceneMode != common.SceneMode_Private {
				logger.Logger.Warn("CSInviteFriendHandler scene is common.SceneMode_Private")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_RoomLimit //只能进入私有房间
				send(p)
				return nil
			}
			//进入房间
			if scene.limitPlatform != nil {
				if scene.limitPlatform.Isolated && p.Platform != scene.limitPlatform.IdStr {
					logger.Logger.Warn("CSInviteFriendHandler scene room not find")
					opRetCode = friend.OpResultCode_OPRC_InviteFriend_RoomNotExist //房间不存在
					send(p)
					return nil
				}
			}
			if scene.deleting {
				logger.Logger.Warn("CSInviteFriendHandler scene is deleting")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_SceneDeleting //场景正在删除
				send(p)
				return nil
			}

			if scene.closed {
				logger.Logger.Warn("CSInviteFriendHandler scene is closed")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_SceneClosed //场景已关闭
				send(p)
				return nil
			}

			dbGameFree := scene.dbGameFree
			if dbGameFree != nil {
				limitCoin := srvdata.CreateRoomMgrSington.GetLimitCoinByBaseScore(int32(scene.gameId), scene.dbGameFree.GetSceneType(), scene.BaseScore)
				if p.Coin < limitCoin {
					logger.Logger.Warn("CSInviteFriendHandler player limitCoin")
					opRetCode = friend.OpResultCode_OPRC_InviteFriend_CoinLimit //金币不足
					send(p)
					return nil
				}
			}

			sp := GetScenePolicy(scene.gameId, scene.gameMode)
			if sp == nil {
				logger.Logger.Warn("CSInviteFriendHandler game not exist")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_GameNotExist //游戏不存在
				send(p)
				return nil
			}
			if reason := sp.CanEnter(scene, p); reason != 0 {
				logger.Logger.Trace("CSInviteFriendHandler CanEnter reason ", reason)
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_GameNotCanEnter //游戏已开始
				send(p)
				return nil
			}
			if scene.IsFull() {
				logger.Logger.Trace("CSInviteFriendHandler sp is full")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_RoomFull //房间已满员
				send(p)
				return nil
			}
			pos := int(msg.GetPos())
			if pos < 0 || pos >= scene.playerNum {
				logger.Logger.Trace("CSInviteFriendHandler pos is fail")
				opRetCode = friend.OpResultCode_OPRC_InviteFriend_PosIsError //座位不存在
				send(p)
				return nil
			}
			if !scene.PlayerEnter(p, pos, true) {
				logger.Logger.Trace("CSInviteFriendHandler EnterScene fail")
				opRetCode = friend.OpResultCode_OPRC_Error //进入房间失败
				send(p)
				return nil
			} else {
				// 进入成功
				for _, v := range scene.players {
					if v == nil || len(v.TaskInviteList) == 0 || v.SnId == p.SnId {
						continue
					}
					if v.TaskInviteList[p.SnId] == scene.sceneId {
						delete(v.TaskInviteList, p.SnId)
						TaskSubjectSingleton.Touch(common.TaskTypeInvitePlay, &TaskData{
							SnId:       v.SnId,
							GameID:     scene.gameId,
							GameFreeID: scene.dbGameFree.GetId(),
							Num:        1,
						})
					}
				}
			}
		case Invite_Refuse:
			logger.Logger.Trace("拒绝邀请")
			send(fp) //通知邀请者
		}
	}
	return nil
}

type CSFuzzyQueryPlayerPacketFactory struct {
}

type CSFuzzyQueryPlayerHandler struct {
}

func (this *CSFuzzyQueryPlayerPacketFactory) CreatePacket() interface{} {
	pack := &friend.CSFuzzyQueryPlayer{}
	return pack
}

func (this *CSFuzzyQueryPlayerHandler) Process(s *netlib.Session, packetid int, data interface{}, sid int64) error {
	logger.Logger.Trace("CSFuzzyQueryPlayerHandler Process recv ", data)
	if msg, ok := data.(*friend.CSFuzzyQueryPlayer); ok {
		p := PlayerMgrSington.GetPlayer(sid)
		if p == nil {
			logger.Logger.Warn("CSFuzzyQueryPlayerHandler p == nil")
			return nil
		}
		queryContent := msg.GetQueryContent()
		if utf8.RuneCountInString(queryContent) < 3 {
			return nil
		}
		pack := &friend.SCFuzzyQueryPlayer{
			QueryContent: proto.String(queryContent),
		}

		// 优先搜索在线玩家
		for _, player := range PlayerMgrSington.snidMap {
			if player != nil && player.IsOnLine() /*&& !player.IsRobot() && !FriendMgrSington.IsFriend(p.SnId, player.SnId)*/ { //在线
				if !player.IsRob && player.Platform != p.Platform { //不同平台的真人不能匹配
					continue
				}
				snidStr := strconv.FormatInt(int64(player.SnId), 10)
				if strings.Contains(player.Name, queryContent) || strings.Contains(snidStr, queryContent) {
					roleId := common.DefaultRoleId
					if player.Roles != nil {
						roleId = int(player.Roles.ModId)
					}
					pi := &friend.PlayerInfo{
						SnId:    proto.Int32(player.SnId),
						Name:    proto.String(player.Name),
						Sex:     proto.Int32(player.Sex),
						Head:    proto.Int32(player.Head),
						HeadUrl: proto.String(player.HeadUrl),
						RoleId:  int32(roleId),
					}
					pack.Players = append(pack.Players, pi)
				}
			}
		}

		if len(pack.Players) > 0 {
			p.SendToClient(int(friend.FriendPacketID_PACKET_SCFuzzyQueryPlayer), pack)
			logger.Logger.Tracef("CSFuzzyQueryPlayerHandler %v", pack)
			return nil
		}

		var err error
		var ls []*model.PlayerBaseInfo
		task.New(nil, task.CallableWrapper(func(o *basic.Object) interface{} {
			snid, _ := strconv.Atoi(queryContent)
			ls = model.FindPlayerList(snid, "", queryContent, 0, 0, "", "", 0, 0, p.Platform, "", 10)
			return nil
		}), task.CompleteNotifyWrapper(func(i interface{}, t task.Task) {
			if err != nil {
				logger.Logger.Errorf("CSFuzzyQueryPlayerHandler err:%v", err)
			}
			for _, v := range ls {
				roleId := common.DefaultRoleId
				if v.Roles != nil {
					roleId = int(v.Roles.ModId)
				}
				pi := &friend.PlayerInfo{
					SnId:    proto.Int32(v.SnId),
					Name:    proto.String(v.Name),
					Sex:     proto.Int32(v.Sex),
					Head:    proto.Int32(v.Head),
					HeadUrl: proto.String(v.HeadUrl),
					RoleId:  int32(roleId),
				}
				pack.Players = append(pack.Players, pi)
			}
			p.SendToClient(int(friend.FriendPacketID_PACKET_SCFuzzyQueryPlayer), pack)
			logger.Logger.Tracef("CSFuzzyQueryPlayerHandler %v", pack)
		})).Start()
	}
	return nil
}

func init() {
	//好友列表 申请列表 推荐列表
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSFriendList), &CSFriendListHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSFriendList), &CSFriendListPacketFactory{})
	//申请 同意 拒绝 删除
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSFriendOp), &CSFriendOpHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSFriendOp), &CSFriendOpPacketFactory{})
	//查看别人战绩
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSQueryPlayerGameLog), &CSQueryPlayerGameLogHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSQueryPlayerGameLog), &CSQueryPlayerGameLogPacketFactory{})
	//邀请好友对战
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSInviteFriend), &CSInviteFriendHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSInviteFriend), &CSInviteFriendPacketFactory{})
	//同意、拒绝好友邀请
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSInviteFriendOp), &CSInviteFriendOpHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSInviteFriendOp), &CSInviteFriendOpPacketFactory{})
	//根据id或者昵称查询玩家:
	common.RegisterHandler(int(friend.FriendPacketID_PACKET_CSFuzzyQueryPlayer), &CSFuzzyQueryPlayerHandler{})
	netlib.RegisterFactory(int(friend.FriendPacketID_PACKET_CSFuzzyQueryPlayer), &CSFuzzyQueryPlayerPacketFactory{})
}