package model

import (
	"encoding/base64"
	"rocommon"
	"rocommon/service"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
	"strconv"
)

func init() {
	//webgm
	serverproto.Handle_DB_SSWebGMChatMsgNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSWebGMChatMsgNtf)
		//util.InfoF("SSWebGMChatMsgNtf msgid=%v", msg)

		UpdatePlayerChatMsg2Mysql(msg.Uid, msg.TargetUid, msg.MsgType, msg.Content)
	})
	//webgm

	serverproto.Handle_DB_SSSaveUserConnectInfo = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSSaveUserConnectInfo)
		DelUserConnInfo(&serverproto.UserConnectInfo{}, msg.OpenId, msg.Platform)
	})

	//获取服务器当前赛季信息
	serverproto.Handle_DB_SSGetServerCompetitionReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		//msg := ev.Msg().(*serverproto.SSGetServerCompetitionReq)
		util.InfoF("SSGetServerCompetitionReq")

		ssAckMsg := &serverproto.SSGetServerCompetitionAck{RounInfo: &serverproto.StRecRound{}}
		ServerCompetitionGet(ssAckMsg)
		model.ServiceReplay(ev, ssAckMsg)
	})
	serverproto.Handle_DB_SSServerCompetitionInfoSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSServerCompetitionInfoSaveNtf)
		util.InfoF("SSServerCompetitionInfoSaveNtf")

		ServerCompetitionSave(msg)
	})

	//角色日志信息写入到mysql中
	serverproto.Handle_DB_SSRoleLogNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleLogNtf)
		//util.InfoF("SSAccountGetRoleListReq msg=%v", msg)
		UpdatePlayerLog2Mysql(msg.LogList)
	})

	serverproto.Handle_DB_SSAccountGetRoleListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSAccountGetRoleListReq)
		util.InfoF("SSAccountGetRoleListReq openid=%v zone=%v", msg.OpenId, msg.ZoneId)

		ack := &serverproto.SSAccountGetRoleListAck{}
		ack.IsCloseRegister = IsServerCloseRegister()
		err := GetRoleListFromRedis(msg.OpenId, msg.ZoneId, ack)
		if err != nil {
			if err != service.NIL {
				//redis操作出错
				util.InfoF("GetRoleListFromRedis err=%v", err)
			}
			util.InfoF("SSAccountGetRoleListReq openid=%v zone=%v account data not empty need create", msg.OpenId, msg.ZoneId)
			//数据不存在
			model.ServiceReplay(ev, ack)
		} else {
			model.ServiceReplay(ev, ack)
		}
	})

	serverproto.Handle_DB_SSAddRoleBaseReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSAddRoleBaseReq)
		util.InfoF("uid=%v SSAddRoleBaseReq", cliId.SessID)

		ack := &serverproto.SSAddRoleBaseAck{}
		if cliId.SessID == 0 {
			util.InfoF("uuid=%v SSAddRoleBaseReq user uuid failed openId=%v", cliId.SessID, msg.OpenId)
			ack.Err = int32(serverproto.ErrorCode_ERROR_FAIL)
			model.ServiceReplay(ev, ack)
			return
		}

		//判断激活码模式下是否已经使用过该激活码
		if msg.ActiveCode != "" {
			retCode := ExistActiveCode(msg.ActiveCode)
			if retCode != serverproto.ErrorCode_ERROR_OK {
				ack.Err = int32(retCode)
				model.ServiceReplay(ev, ack)
				util.InfoF("uuid=%v SSAddRoleBaseReq user base data set redis failed=%v", cliId.SessID, retCode)
				return
			}
		}

		tmpRoleBase := &serverproto.RoleBase{}
		bExist := GetRoleBaseFromRedis(cliId.SessID, tmpRoleBase)
		if bExist {
			//已经存在角色信息，不再重新创建
			ack.Err = int32(serverproto.ErrorCode_ERROR_ROLE_HAS_CREATE)
			ack.CreateRoleUid = tmpRoleBase.Id
		} else {
			//再次进行确认是否已经创建了角色
			tmpAck := &serverproto.SSAccountGetRoleListAck{}
			GetRoleListFromRedis(msg.OpenId, msg.Zone, tmpAck)
			if len(tmpAck.Roles) > 0 {
				//已经存在角色信息，不再重新创建
				ack.Err = int32(serverproto.ErrorCode_ERROR_ROLE_HAS_CREATE)
				ack.CreateRoleUid = tmpAck.Roles[0].Uid
			} else {
				err := SetRoleToRedis(cliId.SessID, msg.Base)
				if err != nil {
					util.InfoF("uuid=%v SSAddRoleBaseReq user base data set redis failed=%v", cliId.SessID, err)
					ack.Err = int32(serverproto.ErrorCode_ERROR_FAIL)
					model.ServiceReplay(ev, ack)
					return
				} else {
					//判断激活码模式下是否已经使用过该激活码
					if msg.ActiveCode != "" {
						retBool := SetActiveCode(msg.ActiveCode, cliId.SessID)
						if !retBool {
							util.InfoF("SSAddRoleBaseReq setActiveCode err=%v", err)
						}
					}
					//添加简介信息
					briefInfo := &serverproto.CommonPlayerBriefInfo{
						Uid:      msg.Base.Id,
						NickName: msg.Base.NickName,
						Gender:   msg.Base.Sex,
						Level:    msg.Base.RoleData.HeroData.BaseLevel,
						ConfigId: msg.Base.RoleData.HeroData.ConfigId,
					}
					UpdatePlayerBriefInfo(cliId.SessID, briefInfo, true, msg.ActiveCode, msg.OpenId, msg.SubPlatform)
				}
			}
			ack.Err = int32(serverproto.ErrorCode_ERROR_OK)
		}
		model.ServiceReplay(ev, ack)
	})

	serverproto.Handle_DB_SSAccountAddRoleNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSAccountAddRoleNtf)
		util.DebugF("SSAccountAddRoleNtf msg=%v", msg)

		if msg.GetRoles() == nil || len(msg.GetRoles()) <= 0 {
			util.InfoF("SSAccountAddRoleNtf role info empty")
			return
		}

		roleInfo := msg.GetRoles()[0]
		roleList := &serverproto.SSAccountGetRoleListAck{}
		//处理多角色列表信息，先获取一次数据
		err := GetRoleListFromRedis(roleInfo.OpenId, roleInfo.ZoneId, roleList)
		if err != nil && err != service.NIL {
			util.InfoF("SSAccountAddRoleNtf openid=%v err=%v", roleInfo.OpenId, err)
		}
		//当前创建的角色添加到角色列表中
		roleList.Roles = append(roleList.Roles, roleInfo)
		err = SetRoleListToRedis(roleInfo.OpenId, roleInfo.ZoneId, roleList)
		if err != nil {
			util.ErrorF("SSAccountAddRoleNtf openid=%v err=%v", roleInfo.OpenId, err)
		}
	})

	serverproto.Handle_DB_SSGetRoleReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRoleReq)
		util.InfoF("uid=%v receive SSGetRoleReq msg=%v", cliId.SessID, msg)

		ack := &serverproto.SSGetRoleAck{
			Err: int32(serverproto.ErrorCode_ERROR_OK),
		}
		err := GetRoleFromRedis(cliId.SessID, ack, msg.RoleRegisterTime)
		if err != nil {
			util.InfoF("uid=%v SSGetRoleReq err=%v", cliId.SessID, err)
			ack.Err = int32(serverproto.ErrorCode_ERROR_FAIL)
		}
		model.ServiceReplay(ev, ack)

		//获取Role其他系统信息，不直接走SSGetRoleAck，避免后续数据包过大
		GetRoleOtherInfoFromRedis(cliId.SessID, ev)

		ntfMsg := &serverproto.SSGetRoleFinishNtf{}
		model.ServiceReplay(ev, ntfMsg)
	})

	//roleBase
	serverproto.Handle_DB_SSRoleBaseSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleBaseSaveReq)
		//util.DebugF("uid=%v SSRoleBaseSaveReq msg=%v", cliId.SessID, msg)

		if msg.Base.Id == 0 {
			util.InfoF("SSRoleBaseSaveReq user uuid failed!!!")
			return
		}
		err := SetRoleToRedis(msg.Base.Id, msg.Base)
		if err != nil {
			util.InfoF("SSRoleBaseSaveReq save err=%v uid=%v", err, cliId.SessID)
		}

		//更新资源信息到mysql
		resData := &serverproto.RoleRes2MysqlInfo{
			Money:         msg.Base.Rmb,
			TotalRecharge: msg.Base.TotalRecharge,
			VipLevel:      msg.Base.VipLevel,
		}
		UpdatePlayerRes2Mysql(msg.Base.Id, resData)

		zone, id := model.ParseUid(msg.Base.Id)
		util.InfoF("SSRoleBaseSaveReq zone=%v id=%v uid=%v", zone, id, cliId.SessID)
	})

	serverproto.Handle_DB_SSGameBanRoleNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGameBanRoleNtf)
		util.DebugF("uid=%v SSGameBanRoleNtf msg=%v", cliId.SessID, msg)

		UpdatePlayerBanInfo2Mysql(msg.BanUid, msg.BanEndTime, msg.BanType)
	})

	//gen name
	serverproto.Handle_DB_SSNameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSNameReq)
		util.DebugF("uid=%v SSNameReq msg=%v", cliId.SessID, msg)

		ntfMsg := &serverproto.SSNameNtf{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
			Name:  msg.Name,
			Type:  msg.Type,
		}

		//玩家Uid
		namePlayerUid := cliId.SessID
		namePlayerUidStr := strconv.FormatUint(namePlayerUid, 10)
		//判断是否重名
		//name需要做base64处理,否则名字中有非法字符，会导致redis操作错乱
		msgStr := base64.StdEncoding.EncodeToString([]byte(msg.Name))
		keyStr := RoleNickNamePrefix + strconv.Itoa(int(msg.Zone)) + "_" + msgStr
		if model.ExistKey(keyStr) {
			ntfMsg.Error = int32(serverproto.ErrorCode_ERROR_NAME_EXIST)
		} else {
			//改名
			if msg.Type == 1 && msg.OldName != "" {
				oldNameStr := base64.StdEncoding.EncodeToString([]byte(msg.OldName))
				oldKeyStr := RoleNickNamePrefix + strconv.Itoa(int(msg.Zone)) + "_" + oldNameStr
				service.GetRedis().Del(oldKeyStr)
			}
			err := model.SetDataToRedis(keyStr, namePlayerUidStr)
			if err != nil {
				util.ErrorF("uid=%v SSNameReq SetDataToRedis err=%v ", cliId.SessID, err)
				ntfMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
			}
		}

		model.ServiceReplay(ev, ntfMsg)
	})

	//hero
	serverproto.Handle_DB_SSHeroDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSHeroDataSaveReq)
		util.DebugF("uuid=%v SSHeroDataSaveReq msg=%v ", cliId.SessID, msg)

		err := SetRoleHeroDataToRedis(cliId.SessID, msg.Hero)
		if err != nil {
			util.InfoF("uuid=%v SSHeroDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//equip
	serverproto.Handle_DB_SSEquipDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSEquipDataSaveReq)
		util.DebugF("uuid=%v SSEquipDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleEquipDataPrefix, cliId.SessID, msg.Equip)
		if err != nil {
			util.InfoF("uuid=%v SSEquipDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//skill equip
	serverproto.Handle_DB_SSSkillEquipDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSSkillEquipDataSaveReq)
		util.DebugF("uid=%v SSSkillEquipDataSaveReq msg=%v", cliId.SessID, msg)
		SetSkillEquipDataToRedis(cliId.SessID, msg)
	})

	//bag
	serverproto.Handle_DB_SSBagDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSBagDataSaveReq)
		util.DebugF("uuid=%v SSBagDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleBagDataPrefix, cliId.SessID, msg.Bag)
		if err != nil {
			util.InfoF("uid=%v SSBagDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//chip
	serverproto.Handle_DB_SSChipDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSChipDataSaveReq)
		util.DebugF("uid=%v SSChipDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleChipDataPrefix, cliId.SessID, msg.Chip)
		if err != nil {
			util.InfoF("uid=%v SSChipDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//map
	serverproto.Handle_DB_SSMapDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSMapDataSaveReq)
		util.DebugF("uid=%v SSMapDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleMapDataPrefix, cliId.SessID, msg.RoleMap)
		if err != nil {
			util.InfoF("uid=%v SSMapDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//card
	serverproto.Handle_DB_SSCardDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCardDataSaveReq)
		//util.DebugF("uid=%v SSCardDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleCardDataPrefix, cliId.SessID, msg.Card)
		if err != nil {
			util.InfoF("uid=%v SSCardDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//fashion
	serverproto.Handle_DB_SSFashionDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSFashionDataSaveReq)
		//util.DebugF("uid=%v SSFashionDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleFashionDataPrefix, cliId.SessID, msg.Fashion)
		if err != nil {
			util.InfoF("uid=%v SSFashionDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//battle
	serverproto.Handle_DB_SSBattleDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSBattleDataSaveReq)
		//util.DebugF("uid=%v SSBattleDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleBattleDataPrefix, cliId.SessID, msg.Battle)
		if err != nil {
			util.InfoF("uid=%v SSBattleDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//task
	serverproto.Handle_DB_SSTaskDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTaskDataSaveReq)
		util.DebugF("uid=%v SSTaskDataSaveReq msg=%v", cliId.SessID, msg)

		SetRoleTaskToRedis(cliId.SessID, msg.Task)
	})

	//red
	serverproto.Handle_DB_SSRoleRedSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleRedSaveReq)
		util.DebugF("uid=%v SSRoleRedSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleRedDataPrefix, cliId.SessID, msg.Red)
		if err != nil {
			util.InfoF("uid=%v SSRoleRedSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//shop
	serverproto.Handle_DB_SSShopDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSShopDataSaveReq)
		util.DebugF("uid=%v SSShopDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleShopDataPrefix, cliId.SessID, msg.Shop)
		if err != nil {
			util.InfoF("uid=%v SSShopDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//activity
	serverproto.Handle_DB_SSActivityDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSActivityDataSaveReq)
		//util.DebugF("uid=%v SSActivityDataSaveReq msg=%v", cliId.SessID, msg)

		SetRoleActivityDataToRedis(cliId.SessID, msg)
	})
	serverproto.Handle_DB_SSActivitySmashEggsMsgSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSActivitySmashEggsMsgSaveNtf)
		//util.DebugF("uid=%v SSActivityDataSaveReq msg=%v", cliId.SessID, msg)

		SetRoleActivitySmashEggsMsgToRedis(msg)
	})

	//competition
	serverproto.Handle_DB_SSCompetitionSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionSaveReq)
		util.DebugF("uid=%v SSCompetitionSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleCompetitionDataPrefix, cliId.SessID, msg.CompetitionData)
		if err != nil {
			util.InfoF("uid=%v SSCompetitionSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//tower
	serverproto.Handle_DB_SSTowerDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTowerDataSaveReq)
		util.DebugF("uid=%v receive SSTowerDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleTowerDataPrefix, cliId.SessID, msg.Tower)
		if err != nil {
			util.InfoF("uid=%v SSTowerDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//guild
	serverproto.Handle_DB_SSGuildDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGuildDataSaveReq)
		util.InfoF("uid=%v receive SSGuildDataSaveReq、 msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleGuildDataPrefix, cliId.SessID, msg.Guild)
		if err != nil {
			util.InfoF("uid=%v SSGuildDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//draw
	serverproto.Handle_DB_SSRoleDrawDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleDrawDataSaveReq)
		//util.DebugF("uid=%v SSRoleDrawDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleDrawDataPrefix, cliId.SessID, msg.RoleDraw)
		if err != nil {
			util.InfoF("uid=%v SSRoleDrawDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//rush
	serverproto.Handle_DB_SSRoleRushDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleRushDataSaveReq)
		//util.DebugF("uid=%v SSRoleDrawDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleRushDataPrefix, cliId.SessID, msg.RoleRush)
		if err != nil {
			util.InfoF("uid=%v SSRoleRushDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//statistics
	serverproto.Handle_DB_SSStatisticsDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSStatisticsDataSaveReq)
		//util.DebugF("uid=%v receive SSStatisticsDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleStatisticDataPrefix, cliId.SessID, msg.Statistics)
		if err != nil {
			util.InfoF("uid=%v SSStatisticsDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//私聊离线消息保存
	serverproto.Handle_DB_SSChatMessageSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSChatMessageSaveReq)
		util.DebugF("uid=%v SSChatMessageSaveReq msg=%v", cliId.SessID, msg)

		AddChatOfflineMsg(msg.FromPlayer, msg.TargetId, msg.OfflineMsg)
	})

	//获取离线私聊消息
	serverproto.Handle_DB_CSChatOfflineMsgReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSChatOfflineMsgReq)
		//util.DebugF("uid=%v CSChatOfflineMsgReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SCChatOfflineMsgAck{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
		}
		err := GetChatOfflineMsgFromRedis(msg.SelfId, msg.TargetId, ackMsg)
		if err != nil {
			util.DebugF("uid=%v CSChatOfflineMsgReq err=%v", cliId.SessID, err)
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_FAIL)
		}

		model.ServiceReplay(ev, ackMsg)
	})
	//获取离线信息玩家列表
	serverproto.Handle_DB_SSChatOfflinePlayerReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		//msg := ev.Msg().(*serverproto.SSChatOfflinePlayerReq)
		//util.DebugF("uid=%v SSChatOfflinePlayerReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSChatOfflinePlayerAck{
			RoleOfflineMsgList: &serverproto.RoleChat{},
		}
		GetChatOfflinePlayerList(cliId.SessID, ackMsg.RoleOfflineMsgList)
		if len(ackMsg.RoleOfflineMsgList.OfflineMsgPlayerList) > 0 {
			model.ServiceReplay(ev, ackMsg)
		}
	})

	//save player brief info
	serverproto.Handle_DB_SSRoleBriefInfoSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRoleBriefInfoSaveReq)
		//util.DebugF("uid=%v SSRoleBriefInfoSaveReq nickname=%v", cliId.SessID, string(msg.BriefInfo.NickName))

		UpdatePlayerBriefInfo(cliId.SessID, msg.BriefInfo, false, msg.ActiveCode, msg.OpenId, msg.SubPlatform)
	})
	//获取简介信息
	serverproto.Handle_DB_SSGetRoleBriefInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRoleBriefInfoReq)
		//util.DebugF("uid=%v SSGetRoleBriefInfoReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSGetRoleBriefInfoAck{
			Type: msg.Type,
		}
		for idx := 0; idx < len(msg.PlayerUidList); idx++ {
			err, bfInfo := GetPlayerBriefInfo(msg.PlayerUidList[idx])
			if err != nil {
				continue
			}
			ssAckMsg.BriefInfo = append(ssAckMsg.BriefInfo, bfInfo)
		}
		model.ServiceReplay(ev, ssAckMsg)
	})

	//save arena
	serverproto.Handle_DB_SSArenaDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaDataSaveReq)
		//util.DebugF("uid=%v SSArenaDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleArenaDataPrefix, cliId.SessID, msg.RoleArena)
		if err != nil {
			util.InfoF("uid=%v SSArenaDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//arena 匹配操作
	serverproto.Handle_DB_SSArenaMatchReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaMatchReq)
		util.DebugF("uid=%v SSArenaMatchReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSArenaMatchAck{}
		ackMsg.FightInfo = ArenaMatch(cliId.SessID, msg.Score, msg.LastPlayerUid, msg.MatchLeft, msg.MatchRight, msg.TopMatchLeft)

		model.ServiceReplay(ev, ackMsg)
	})

	//mail 邮件数据变更
	serverproto.Handle_DB_SSMailSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSMailSaveNtf)
		util.DebugF("uid=%v SSMailSaveNtf msg=%v", cliId.SessID, msg)

		SetMailDataChangToRedis(cliId.SessID, msg.MailStateList, msg.DelMailList, msg.AddMailList, msg.MaxMailId, msg.CurGlobalMailId)
	})

	//添加邮件(离线方式添加到db中，在线添加在SSMailSaveNtf中)
	serverproto.Handle_DB_SSAddMailNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSAddMailNtf)
		util.DebugF("uid=%v SSAddMailNtf msg=%v", cliId.SessID, msg)

		mail := &serverproto.MailContent{
			ConfigId: msg.MailConfigId,
			Type:     msg.MailType,
		}
		if msg.MailType == int32(serverproto.MailType_MailType_GM) ||
			msg.MailType == int32(serverproto.MailType_MailType_GM_Self) {
			mail.ConfigId = 0
			mail.Title = msg.Title
			mail.Content = msg.Content
			mail.BeginTime = util.GetTimeMilliseconds()
			mail.ExpireTime = util.GetTimeMilliseconds() + 30*24*60*60*1000
		}
		if len(msg.MailParamList) > 0 {
			mail.ParamList = append(msg.MailParamList)
		}
		if len(msg.RewardList) > 0 {
			mail.RewardList = append(msg.RewardList)
		}

		for _, uid := range msg.NotifyList {
			AddMailToRedis(uid, mail)
		}
	})

	//观察玩家
	serverproto.Handle_DB_SSGetOtherTargetInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetOtherTargetInfoReq)
		//util.DebugF("uid=%v SSGetOtherTargetInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetOtherTargetInfoAck{
			Uid:  msg.Uid,
			TUid: msg.TUid,
		}
		ackMsg.Info = &serverproto.ViewRoleInfo{}
		err := GetOtherViewInfo(msg.TUid, ackMsg.Info)
		ackMsg.Error = err

		model.ServiceReplay(ev, ackMsg)
	})

	//根据名字获取玩家uid(uidList可能有多个玩家)
	serverproto.Handle_DB_SSGetUidByRoleNameReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetUidByRoleNameReq)
		//util.DebugF("uid=%v SSGetUidByRoleNameReq msg=%v", cliId.SessID, msg)

		//根据创建角色时加入默认名字查找列表中，最大长度20个，如果发生了改名字操作则从列表中移除
		ackMsg := &serverproto.SSGetUidByRoleNameAck{}
		GetNameSearchList(msg.SearchName, msg.SelfUid, msg.Zone, ackMsg)

		model.ServiceReplay(ev, ackMsg)
	})

	////social
	//social未找到直接发送给db处理
	serverproto.Handle_DB_SSDBFriendAddFansReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDBFriendAddFansReq)
		util.DebugF("uid=%v SSDBFriendAddFansReq msg=%v", cliId.SessID, msg)

		ret, addBFInfo := FriendAddFans(msg.FromUid, msg.AddUid)

		ssAckMsg := &serverproto.SSDBFriendAddFansAck{
			Error:   int32(serverproto.ErrorCode_ERROR_OK),
			FromUid: msg.FromUid,
		}
		if ret != int32(serverproto.ErrorCode_ERROR_OK) {
			ssAckMsg.Error = ret
		} else {
			ssAckMsg.AddUid = addBFInfo
		}
		model.ServiceReplay(ev, ssAckMsg)
	})
	//从delUid中移除粉丝fromUid
	serverproto.Handle_DB_SSDBFriendDelFansNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDBFriendDelFansNtf)
		util.DebugF("uid=%v SSDBFriendDelFansNtf msg=%v", cliId.SessID, msg)

		FriendDelFans(msg.FromUid, msg.DelUid)
	})
	//friend save data
	serverproto.Handle_DB_SSFriendDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSFriendDataSaveReq)
		util.DebugF("uid=%v SSFriendDataSaveReq msg=%v", cliId.SessID, msg)

		SetFriendDataToRedis(cliId.SessID, msg)
	})

	//互粉好友简介信息
	serverproto.Handle_DB_SSGetFriendTowerInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetFriendTowerInfoReq)
		util.DebugF("uid=%v SSGetFriendTowerInfoReq msg=%v", cliId.SessID, msg)

		GetFriendBriefFromRedis(msg.UidList, msg.Begin, msg.End, ev)
	})

	////pet
	serverproto.Handle_DB_SSPetDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetDataSaveReq)
		util.DebugF("uid=%v SSPetDataSaveReq msg=%v", cliId.SessID, msg)

		SetRolePetDataToRedis(cliId.SessID, msg)
	})
	//设置玩家宠物援助信息
	serverproto.Handle_DB_SSPetSetAssistNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetSetAssistNtf)
		util.DebugF("uid=%v SSPetSetAssistNtf msg=%v", cliId.SessID, msg)

		SetRolePetAssistDataToRedis(cliId.SessID, msg)
	})
	//获取其他援助玩家的宠物信息(羁绊信息，已经设置在玩家的羁绊列表中，检查合法性)
	serverproto.Handle_DB_SSPetQueryAssistInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetQueryAssistInfoReq)
		util.DebugF("uid=%v SSPetQueryAssistInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSPetQueryAssistInfoAck{
			Notify: msg.Notify,
		}
		RolePetQueryAssistInfo(cliId.SessID, msg, ackMsg)

		model.ServiceReplay(ev, ackMsg)
	})
	//获取激活羁绊所需的宠物列表(援助列表)
	serverproto.Handle_DB_SSPetBondAssistListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetBondAssistListReq)
		util.DebugF("uid=%v SSPetBondAssistListReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSPetBondAssistListAck{
			BondCfgId: msg.BondCfgId,
		}

		RolePetBondAssistListGet(cliId.SessID, msg, ackMsg)

		model.ServiceReplay(ev, ackMsg)
	})
	//最早收集到宠物最高进阶等级获取
	serverproto.Handle_DB_SSPetAdvAchievementReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetAdvAchievementReq)
		util.DebugF("uid=%v SSPetAdvAchievementReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSPetAdvAchievementAck{
			PetCfgId: msg.PetCfgId,
		}

		PetAdvAchievementGet(msg.PetCfgId, ackMsg)

		model.ServiceReplay(ev, ackMsg)
	})
	serverproto.Handle_DB_SSPetAdvAchievementSetNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPetAdvAchievementSetNtf)
		util.DebugF("uid=%v SSPetAdvAchievementSetNtf msg=%v", cliId.SessID, msg)

		PetAdvAchievementSet(cliId.SessID, msg.PetCfgId, msg.AdvLevel)
	})

	////expedition
	//救助发起求助的玩家 FromUid发起救助操作的玩家  BeHelpedUid发起求助的放玩家
	serverproto.Handle_DB_SSExpeditionDBHelpReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionDBHelpReq)
		util.DebugF("uid=%v SSExpeditionDBHelpReq msg=%v", cliId.SessID, msg)

		ret := ExpeditionHelp(msg.FromUid, msg.BeHelpedUid)

		ssAckMsg := &serverproto.SSExpeditionDBHelpAck{
			Error:       int32(ret),
			FromUid:     msg.FromUid,
			BeHelpedUid: msg.BeHelpedUid,
		}

		model.ServiceReplay(ev, ssAckMsg)
	})

	////invitation
	//save
	serverproto.Handle_DB_SSInvitationSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationSaveNtf)
		//util.DebugF("uid=%v SSInvitationSaveNtf msg=%v", cliId.SessID, msg)

		SetInvitationDataToRedis(cliId.SessID, msg)
	})
	//生成邀请码/判断导师是否合法
	serverproto.Handle_DB_SSInvitationGenNumberReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationGenNumberReq)
		util.DebugF("uid=%v SSInvitationGenNumberReq msg=%v", cliId.SessID, msg)

		genNumber, checkMasterUid := InvitationGenNumber(cliId.SessID, msg.GenNumber, msg.MasterUid)

		ssAckMsg := &serverproto.SSInvitationGenNumberAck{
			InvitationNumber: genNumber,
			MasterUid:        checkMasterUid,
		}
		model.ServiceReplay(ev, ssAckMsg)
	})
	//master玩家最近未上线，db操作
	serverproto.Handle_DB_SSInvitationBeToMemberDBReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationBeToMemberDBReq)
		util.DebugF("uid=%v SSInvitationBeToMemberDBReq msg=%v", cliId.SessID, msg)

		ret := InvitationBeToBeMember(msg.MasterNumber, msg.MasterUid, msg.SelfUid)
		ssAckMsg := &serverproto.SSInvitationBeToMemberDBAck{
			Error:        int32(ret),
			MasterNumber: msg.MasterNumber,
			MasterUid:    msg.MasterUid,
			SelfUid:      msg.SelfUid,
		}
		model.ServiceReplay(ev, ssAckMsg)
	})
	//根据邀请码查询玩家信息
	serverproto.Handle_DB_SSInvitationNumberUserInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationNumberUserInfoReq)
		util.DebugF("uid=%v SSInvitationNumberUserInfoReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSInvitationNumberUserInfoAck{}
		InvitationGetUserInfoByNumber(cliId.SessID, msg.Number, ssAckMsg)

		model.ServiceReplay(ev, ssAckMsg)
	})
	//等级,充值等数据变更时通知导师(导师不在线保存到数据库)
	serverproto.Handle_DB_SSInvitationMemberNoticeMasterNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSInvitationMemberNoticeMasterNtf)
		util.DebugF("uid=%v SSInvitationMemberNoticeMasterNtf msg=%v", cliId.SessID, msg)

		InvitationMemberDataChangeNotice(msg.SelfUid, msg.MasterUid, msg.Param)
	})

	////pay
	//充值订单数据保存
	serverproto.Handle_DB_SSPayInfoSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayInfoSaveReq)
		util.DebugF("uid=%v SSPayInfoSaveReq msg=%v", cliId.SessID, msg)

		ret := SetPayOrderInfoToRedis(cliId.SessID, msg.PayOrderInfo)
		if msg.SaveNotify {
			ssAckMsg := &serverproto.SSPayInfoSaveAck{
				Error:        int32(ret),
				PayOrderInfo: msg.PayOrderInfo,
			}
			model.ServiceReplay(ev, ssAckMsg)
		}
	})
	//上线获取成功成但是没有获取奖励的订单数据
	serverproto.Handle_DB_SSPayInfoOrderOKListGetReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPayInfoOrderOKListGetReq)
		util.DebugF("uid=%v SSPayInfoOrderOKListGetReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSPayInfoOrderOkListGetAck{}
		GetPayOrderOkListFromRedis(cliId.SessID, ssAckMsg)
		model.ServiceReplay(ev, ssAckMsg)
	})

	serverproto.Handle_DB_SSRuneDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRuneDataSaveReq)
		//util.DebugF("uid=%v SSRuneDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetRoleRuneDataToRedis(cliId.SessID, msg.RoleRune)
		if err != nil {
			util.InfoF("uuid=%v SSHeroDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	//keepsake
	serverproto.Handle_DB_SSKeepSakeSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSKeepSakeSaveReq)
		util.DebugF("uid=%v SSKeepSakeSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleKeepSakeDataPrefix, cliId.SessID, msg.RoleKeepSake)
		if err != nil {
			util.InfoF("uid=%v SSKeepSakeSaveReq save err=%v", cliId.SessID, err)
		}
	})

	////百人道场
	serverproto.Handle_DB_SSDaoChang100SaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100SaveNtf)
		//util.DebugF("uid=%v SSDaoChang100SaveNtf msg=%v", cliId.SessID, msg)

		SetRoleDaoChang100ToRedis(cliId.SessID, msg.SaveData)
	})
	//百人道场转盘大奖日志
	serverproto.Handle_DB_CSDaoChang100WheelLogReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		ssAckMsg := &serverproto.SCDaoChang100WheelLogAck{}
		GetRoleDaoChang100WheelLogListFromRedis(ssAckMsg)
		model.ServiceReplay(ev, ssAckMsg)
	})
	serverproto.Handle_DB_SSDaoChang100WheelLogAddNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100WheelLogAddNtf)
		SetRoleDaoChang100WheelLogToRedis(cliId.SessID, msg)
	})

	////远航试炼
	serverproto.Handle_DB_SSCrossDataSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCrossDataSaveNtf)
		util.DebugF("uid=%v SSCrossDataSaveNtf msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleCrossPrefix, cliId.SessID, msg.SaveData)
		if err != nil {
			util.InfoF("uid=%v SSCrossDataSaveNtf save err=%v", cliId.SessID, err)
		}
	})
	//远航被挑战日志保存
	serverproto.Handle_DB_SSCrossYuanHangTrialLogNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCrossYuanHangTrialLogNtf)
		util.DebugF("uid=%v SSCrossYuanHangTrialLogNtf msg=%v", msg.NtfUid, msg)

		SetRoleCrossYuanHangLogToRedis(msg)
	})

	//称号数据保存
	serverproto.Handle_DB_SSHeadDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSHeadDataSaveReq)
		//util.DebugF("uid=%v SSFashionDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleHeadDataPrefix, cliId.SessID, msg.Head)
		if err != nil {
			util.InfoF("uid=%v SSHeadDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	serverproto.Handle_DB_SSUpdateHeadDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSUpdateHeadDataSaveReq)
		util.DebugF("uid=%v SSUpdateHeadDataSaveReq msg=%v", cliId.SessID, msg)

		headData := &serverproto.RoleHead{}
		err := GetSystemDataFromRedis(RoleHeadDataPrefix, msg.Uid, headData)
		if err != nil && err != service.NIL {
			util.InfoF("uid=%v [SSUpdateHeadDataSaveReq] RoleHead err:%v", msg.Uid, err)
			return
		}
		for _, data := range headData.Heads {
			if data.HeadId != msg.HeadId {
				continue
			}
			data.State = msg.State
			break
		}
		err1 := SetSystemDataToRedis(RoleHeadDataPrefix, msg.Uid, headData)
		if err1 != nil {
			util.InfoF("uid=%v SSUpdateHeadDataSaveReq update err=%v", msg.Uid, err)
		}
	})

	//许愿想数据保存
	serverproto.Handle_DB_SSWishBoxDataSaveReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSWishBoxDataSaveReq)
		//util.DebugF("uid=%v SSFashionDataSaveReq msg=%v", cliId.SessID, msg)

		err := SetSystemDataToRedis(RoleWishBoxDataPrefix, cliId.SessID, msg.Wishs)
		if err != nil {
			util.InfoF("uid=%v SSWishBoxDataSaveReq save err=%v", cliId.SessID, err)
		}
	})

	// bt
	// 波利商城
	serverproto.Handle_DB_SSBTDataSaveNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSBTDataSaveNtf)
		//util.DebugF("uid=%v SSFashionDataSaveReq msg=%v", cliId.SessID, msg)

		SetBTDataToRedis(cliId.SessID, msg)
	})

}