package msg

import (
	"rocommon"
	"rocommon/util"
	"roserver/baseserver/model"
	rankMode "roserver/rank/model"
	"roserver/serverproto"
)

func init() {
	///MapRank
	//地图挑战进度变更(大地图显示使用)
	serverproto.Handle_RANK_SSMapLevelChangeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSMapLevelChangeReq)
		util.DebugF("receive SSMapLevelChangeReq msg=%v uid=%v", msg, cliId.SessID)

		ackMsg := &serverproto.SSMapLevelChangeAck{
			Error: int32(serverproto.ErrorCode_ERROR_BATTLE_NOT_IN_RANK),
			//Error:  int32(serverproto.ErrorCode_ERROR_FAIL),
			Notify: false,
		}

		var selfRank uint32 = 0
		var totalRank uint32 = 0
		var battleRecordId uint64 = 0
		//获取排名
		if msg.NewMapLevelId == 0 && msg.PassTime == 0 {
			selfRank, totalRank = rankMode.GetMapRank(cliId.SessID)
			ackMsg.Notify = true
		} else {
			//设置排名
			selfRank, totalRank, battleRecordId = rankMode.AddMapRank(cliId.SessID, msg.NewMapLevelId, msg.PassTime, msg.RecordInfo)
			ackMsg.BattleRecordId = battleRecordId
			ackMsg.RecordTimeStamp = msg.RecordInfo.RecordTime
		}

		if totalRank > 0 {
			ackMsg.Error = int32(serverproto.ErrorCode_ERROR_OK)
			ackMsg.Rank = selfRank + 1
		}
		ackMsg.RankPlayers = totalRank
		ackMsg.TopPlayerList = append(rankMode.MapRankTopThree)

		util.DebugF("SSMapLevelChangeReq ackMsg=%v uid=%v newmaplevel=%v selfRank=%v", ackMsg, cliId.SessID, msg.NewMapLevelId, selfRank)
		model.ServiceReplay(ev, ackMsg)
	})

	//set max fight power rank
	serverproto.Handle_RANK_SSMaxFightPowerRankNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSMaxFightPowerRankNtf)
		util.DebugF("receive SSMaxFightPowerRankNtf msg:%v [%v]", msg, cliId.SessID)

		rankMode.AddMaxFightPowerRank(cliId.SessID, msg.MaxFightPower)
	})

	///Arena
	//set arena score rank
	serverproto.Handle_RANK_SSArenaScoreRankNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaScoreRankNtf)
		util.DebugF("receive SSArenaScoreRankNtf msg:%v [%v]", msg, cliId.SessID)

		rankMode.SetArenaScoreRank(cliId.SessID, msg.Score, util.GetTimeMilliseconds(),
			msg.OldScore, msg.MinTopScore, msg.TopRankNum)
	})

	//获取英灵殿赛季排行榜 arena
	serverproto.Handle_RANK_SSArenaRankListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankListReq)
		util.DebugF("receive SSArenaRankListReq msg:%v [%v]", msg, cliId.SessID)

		ssAckMsg := &serverproto.SSArenaRankListAck{
			Error:    int32(serverproto.ErrorCode_ERROR_OK),
			RankType: msg.RankType,
			StartIdx: msg.StartIdx,
		}
		selfRank := rankMode.GetArenaRankList(cliId.SessID, msg.RankType, msg.StartIdx, msg.LastSeasonId, ssAckMsg)
		if selfRank > 0 {
			ssAckMsg.SelfRank = selfRank
		}

		model.ServiceReplay(ev, ssAckMsg)
	})

	//获取英灵殿赛季奖励
	serverproto.Handle_RANK_SSArenaRankRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankRewardReq)
		util.DebugF("receive SSArenaRankRewardReq msg:%v [%v]", msg, cliId.SessID)

		selfRank, seasonId := rankMode.GetArenaRankReward(msg.Uid, msg.Score, msg.SeasonId)

		ssAckMsg := &serverproto.SSArenaRankRewardAck{
			SelfRank:       selfRank,
			RewardSeasonId: seasonId,
		}
		model.ServiceReplay(ev, ssAckMsg)
	})

	//更新英灵殿赛季数据(生成赛季排行榜)
	serverproto.Handle_RANK_SSArenaRankUpdateReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSArenaRankUpdateReq)
		util.DebugF("receive SSArenaRankUpdateReq msg:%v [%v]", msg, cliId.SessID)

		ssAckMsg := &serverproto.SSArenaRankUpdateAck{
			RewardSeasonId: msg.LastSeasonId,
		}

		ret := rankMode.UpdateArenaRank(msg.LastSeasonId, &(msg.RewardPlayerList), &(ssAckMsg.RewardPlayerList))
		ssAckMsg.Error = int32(ret)

		model.ServiceReplay(ev, ssAckMsg)
	})

	///Competition
	//获取对应赛季信息 from game
	serverproto.Handle_RANK_SSGetCompetitionDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetCompetitionDataReq)
		util.DebugF("uid=%v receive SSGetCompetitionDataReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSGetCompetitionDataAck{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
			CompetitionData: &serverproto.CompetitionInfo{
				CompetitionId: msg.CompetitionId,
			},
		}
		rankMode.CompetitionMag.GetCompetitionData(cliId.SessID, msg.CompetitionId, msg.SubIdNum,
			msg.IsNowCompetition, (model.CompetitionType)(msg.CompetitionType), ssAckMsg)

		model.ServiceReplay(ev, ssAckMsg)
	})
	//赛季结算奖励 from game
	serverproto.Handle_RANK_SSCompetitionRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionRewardReq)
		util.DebugF(" uid=%v receive SSCompetitionRewardReq msg=%v ", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSCompetitionRewardAck{
			CompetitionId: msg.CompetitionId,
		}
		rankMode.CompetitionMag.CompetitionFinish(msg, ssAckMsg)

		model.ServiceReplay(ev, ssAckMsg)
	})
	//更新积分赛季排名 from game
	serverproto.Handle_RANK_SSCompetitionUpdateScoreReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionUpdateScoreReq)
		util.DebugF("uid=%v receive SSCompetitionUpdateScoreReq msg=%v", cliId.SessID, msg)

		curVoteTicket := msg.CurVoteScore
		totalScore := int32(0)
		if msg.CompetitionId == int32(model.CompetitionType_Idol) {
			totalScore = rankMode.CompetitionMag.FansVoteChange(msg.Uid, msg.FansUid, msg.CurVoteScore, msg.CompetitionId)
			//redis查询出错,就不能继续走下去了
			if totalScore == -1 {
				return
			}
			//在rank计算被投票人总票数（）
			msg.Score = totalScore
		}

		//老的投票流程 开始
		ssAckMsg := &serverproto.SSCompetitionUpdateScoreAck{
			CompetitionId: msg.CompetitionId,
		}
		rankMode.CompetitionMag.UpdateRankByScore(msg.CompetitionId, msg.Uid, msg.Score, ssAckMsg)
		model.ServiceReplay(ev, ssAckMsg)
		//老的投票流程 结束

		if msg.CompetitionId == int32(model.CompetitionType_Idol) {
			ntfMsg := &serverproto.SSCompetitionOnVoteNtf{
				Uid: msg.Uid,
				VoteTarget: &serverproto.FansRankData{
					Uid: msg.Uid,
				},
				TicketCount: curVoteTicket,
			}

			rankMode.CompetitionMag.GetVoteDetail(msg.CompetitionId, ntfMsg)
			model.ServiceReplay(ev, ntfMsg)
		}
	})
	//上线时一次性获取历史赛季奖励 from game
	serverproto.Handle_RANK_SSCompetitionRewardHistoryReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionRewardHistoryReq)
		util.DebugF("uid=%v receive SSCompetitionRewardHistoryReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSCompetitionRewardHistoryAck{
			ECompetitionId:    msg.ECompetitionId,
			ECompetitionSubId: msg.ECompetitionSubId,
		}
		rankMode.CompetitionMag.GetHistoryCompetitionReward(cliId.SessID,
			msg.SCompetitionId, msg.SCompetitionSubId, msg.ECompetitionId, msg.ECompetitionSubId, ssAckMsg)

		if len(ssAckMsg.RewardUidList) > 0 {
			model.ServiceReplay(ev, ssAckMsg)
		}
	})

	//更新通关战力//查看是否更新全服排名
	serverproto.Handle_RANK_SSTowerPassFightPowerNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTowerPassFightPowerNtf)
		util.DebugF("uid=%v receive SSTowerPassFightPowerNtf msg=%v", cliId.SessID, msg)

		//处理是否更新最新排名
		bRet := false
		if msg.IsGm == false {
			bRet = rankMode.TowerMag.AddMinFightList(msg.TowerBfInfo)
		} else {
			bRet = rankMode.TowerMag.AddMinFightListGM(msg.TowerBfInfo)
		}
		if bRet == true { //如果当前战斗有突破，则通知这个玩家最小战力通关榜
			ackMsg := &serverproto.SSTowerMinFightPowerAck{
				BattleRecordId:  msg.TowerBfInfo.CommonInfo.BattleRecordId,
				RecordTimeStamp: msg.RecordTimeStamp,
				Notify:          true,
			}
			rankMode.TowerMag.GetMinFightList(msg.TowerBfInfo.CommonInfo.TowerLevel, ackMsg)
			model.ServiceReplay(ev, ackMsg)
		}
		//处理更新全服排名
		rankMode.TowerMag.AddTowerLevelRank(msg.TowerBfInfo.CommonInfo)
	})

	//请求通关最小战力
	serverproto.Handle_RANK_SSTowerMinFightPowerReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTowerMinFightPowerReq)
		util.DebugF("uid=%v receive SSTowerMinFightPowerReq msg=%v", cliId.SessID, msg)

		//请求最小通关榜
		ackMsg := &serverproto.SSTowerMinFightPowerAck{}
		rankMode.TowerMag.GetMinFightList(msg.TowerLevel, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})

	//请求关卡排名
	serverproto.Handle_RANK_SSPassTowerLevelRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSPassTowerLevelRankReq)
		util.DebugF("uid=%v receive SSPassTowerLevelRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSPassTowerLevelRankAck{}
		rankMode.TowerMag.GetTopTowerRank(msg.Uid, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})

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

		ackMsg := &serverproto.SCPlayerBattleRecordAck{
			Error: int32(serverproto.ErrorCode_ERROR_OK),
		}

		recordType := msg.RecordType / 100
		//subRecordType := msg.RecordType % 100
		if recordType == int32(serverproto.BattleRecordType_BattleRecordType_Normal) {
			rankMode.GetBattleRecordMap(ackMsg, msg.ParamList)
		}
		model.ServiceReplay(ev, ackMsg)
	})

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

		rankMode.CardCollectMag.OnCardCollectChange(msg.Uid, msg.CardId, msg.CardLevel)
	})

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

		rankMode.CardCollectMag.CardRankInfo(msg, ev)
	})

	///百人道场
	//获取玩家自身占位信息
	serverproto.Handle_RANK_CSDaoChang100PlayerInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSDaoChang100PlayerInfoReq)
		util.DebugF("uid=%v receive CSDaoChang100PlayerInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SCDaoChang100PlayerInfoAck{}
		rankMode.DaoChang100Mag.GetPosInfoByUid(msg.PlayerUid, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})
	//获取占位信息
	serverproto.Handle_RANK_SSDaoChang100PosInfoListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100PosInfoListReq)
		//util.DebugF("uid=%v receive SSDaoChang100PosInfoListReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSDaoChang100PosInfoListAck{}
		rankMode.DaoChang100Mag.GetPosInfoList(msg.PosIdxList, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})
	//发起占位挑战
	serverproto.Handle_RANK_SSDaoChang100ChallengeReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100ChallengeReq)
		util.DebugF("uid=%v receive SSDaoChang100ChallengeReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSDaoChang100ChallengeAck{}
		rankMode.DaoChang100Mag.ChallengePre(msg.PosIdx, msg.HasChallengeCount, msg.OwnerBrief, ackMsg, ev)
		model.ServiceReplay(ev, ackMsg)
	})
	//挑战成功/失败通知
	serverproto.Handle_RANK_SSDaoChang100ChallengeResultReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100ChallengeResultReq)
		util.DebugF("uid=%v receive SSDaoChang100ChallengeResultReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSDaoChang100ChallengeResultAck{}
		rankMode.DaoChang100Mag.ChallengeResult(msg.PosIdx, msg.PosUid, msg.OwnerBrief, msg.BattleResult, ackMsg, ev)
		model.ServiceReplay(ev, ackMsg)
	})
	//获取收益奖励
	serverproto.Handle_RANK_SSDaoChang100TimeRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100TimeRewardReq)
		util.DebugF("uid=%v receive SSDaoChang100TimeRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSDaoChang100TimeRewardAck{}
		rankMode.DaoChang100Mag.TimeReward(msg.Uid, msg.BaseRewardTime, msg.RewardIntervalTime, msg.NowTime, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})
	//占领日志信息
	serverproto.Handle_RANK_SSDaoChang100LogReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSDaoChang100LogReq)
		util.DebugF("uid=%v receive SSDaoChang100LogReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSDaoChang100LogAck{}
		rankMode.DaoChang100Mag.GetPosIdxLog(cliId.SessID, msg.BeginTime, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})

	//请求冲榜赛季数据
	serverproto.Handle_RANK_SSOnlineGetRushInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSOnlineGetRushInfoReq)
		util.DebugF("uid=%v receive SSOnlineGetRushInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSOnlineGetRushInfoAck{
			Uid: msg.Uid,
		}
		//打包爬塔冲榜数据
		towerRushData := &serverproto.RushActivityData{
			RushType: model.Rush_Type_Tower,
		}
		rankMode.TowerMag.GetCurRushInfo(towerRushData)
		ackMsg.RushData = append(ackMsg.RushData, towerRushData)

		//打包英灵殿冲榜数据
		arenaRushData := &serverproto.RushActivityData{
			RushType: model.Rush_Type_Arena,
		}
		rankMode.ArenaMag.GetCurRushInfo(arenaRushData)
		ackMsg.RushData = append(ackMsg.RushData, arenaRushData)

		//打包推图冲榜数据
		mapRushData := &serverproto.RushActivityData{
			RushType: model.Rush_Type_Map,
		}
		rankMode.MapScoreMag.GetCurRushInfo(mapRushData)
		ackMsg.RushData = append(ackMsg.RushData, mapRushData)

		//打包宠物冲榜数据
		petRushData := &serverproto.RushActivityData{
			RushType: model.Rush_Type_Pet,
		}
		rankMode.PetRankMag.GetCurRushInfo(petRushData)
		ackMsg.RushData = append(ackMsg.RushData, petRushData)

		//打包技能冲榜数据
		skillRushData := &serverproto.RushActivityData{
			RushType: model.Rush_Type_Skill,
		}
		rankMode.SkillRankMag.GetCurRushInfo(skillRushData)
		ackMsg.RushData = append(ackMsg.RushData, skillRushData)

		model.ServiceReplay(ev, ackMsg)
	})

	//获取冲榜详细信息
	serverproto.Handle_RANK_SSGetRushDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushDataReq)
		util.DebugF("uid=%v receive SSGetRushDataReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushDataAck{
			Uid:      msg.Uid,
			RushType: msg.RushType,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.GetSelfRushData(ackMsg)
		} else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.GetSelfRushData(ackMsg)
		} else if msg.RushType == model.Rush_Type_Map {
			rankMode.MapScoreMag.GetSelfRushData(ackMsg)
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.GetSelfRushData(ackMsg)
		} else if msg.RushType == model.Rush_Type_Skill {
			rankMode.SkillRankMag.GetSelfRushData(ackMsg)
		}
		model.ServiceReplay(ev, ackMsg)
	})

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

		ackMsg := &serverproto.SSRushDataChangeAck{
			Uid:      msg.Uid,
			RushType: msg.RushType,
			Score:    msg.Score,
			Score2:   msg.Score2,
			Score3:   msg.Score3,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.CheckRushTowerAddScore(ackMsg)
		} else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.CheckRushArenaAddScore(ackMsg)
		} else if msg.RushType == model.Rush_Type_Map {
			rankMode.MapScoreMag.CheckRushMapAddScore(ackMsg)
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.CheckRushPetAddScore(ackMsg)
		} else if msg.RushType == model.Rush_Type_Skill {
			rankMode.SkillRankMag.CheckRushSkillAddScore(ackMsg)
		}

		model.ServiceReplay(ev, ackMsg)
	})
	//主动领取排名奖励请求
	serverproto.Handle_RANK_SSGetRushRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushRewardReq)
		util.DebugF("uid=%v receive SSGetRushRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushRewardAck{
			Uid:        msg.Uid,
			RewardType: msg.RewardType,
			RushType:   msg.RushType,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.GetRushTowerReward(ackMsg, msg.RewardType)
		}  else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.GetRushArenaReward(ackMsg, msg.RewardType)
		} else if msg.RushType == model.Rush_Type_Map {
			rankMode.MapScoreMag.GetRushMapReward(ackMsg, msg.RewardType)
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.GetRushPetReward(ackMsg, msg.RewardType)
		} else if msg.RushType == model.Rush_Type_Skill {
			rankMode.SkillRankMag.GetRushSkillReward(ackMsg, msg.RewardType)
		}
		model.ServiceReplay(ev, ackMsg)
	})

	//主动领取保底奖励请求
	serverproto.Handle_RANK_SSGetRushBaseRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushBaseRewardReq)
		util.DebugF("uid=%v receive SSGetRushBaseRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushBaseRewardAck{
			Uid:      msg.Uid,
			RushType: msg.RushType,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.GetRushBaseReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.GetRushBaseReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Map {
			rankMode.MapScoreMag.GetRushBaseReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.GetRushBaseReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Skill {
			rankMode.SkillRankMag.GetRushBaseReward(msg.Uid, msg.RushRound, ackMsg)
		}

		model.ServiceReplay(ev, ackMsg)
	})

	//冲榜商店信息请求
	serverproto.Handle_RANK_SSGetRushShopInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushShopInfoReq)
		util.DebugF("uid=%v receive SSGetRushShopInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushShopInfoAck{
			Uid:       msg.Uid,
			RushType:  msg.RushType,
			ShopType:  msg.ShopType,
			SubShopId: msg.SubShopId,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rushStage, rushId := rankMode.TowerMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Arena {
			rushStage, rushId := rankMode.ArenaMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Map {
			rushStage, rushId := rankMode.MapScoreMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Pet {
			rushStage, rushId := rankMode.PetRankMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Skill {
			rushStage, rushId := rankMode.SkillRankMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		}

		model.ServiceReplay(ev, ackMsg)
	})

	//冲榜商店购买请求
	serverproto.Handle_RANK_SSGetRushShopBuyReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushShopBuyReq)
		util.DebugF("uid=%v receive SSGetRushShopBuyReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushShopBuyAck{
			Uid:      msg.Uid,
			ShopType: msg.ShopType,
			GoodsId:  msg.GoodsId,
			GoodsNum: msg.GoodsNum,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rushStage, rushId := rankMode.TowerMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Arena {
			rushStage, rushId := rankMode.ArenaMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Map {
			rushStage, rushId := rankMode.MapScoreMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Pet {
			rushStage, rushId := rankMode.PetRankMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		} else if msg.RushType == model.Rush_Type_Skill {
			rushStage, rushId := rankMode.SkillRankMag.GetRushInfo()
			ackMsg.RushStage = rushStage
			ackMsg.RushRound = rushId
		}
		model.ServiceReplay(ev, ackMsg)
	})

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

		ackMsg := &serverproto.SSGetRushRankRewardAck{
			Uid:      msg.Uid,
		}
		for _, data := range msg.RushData {
			reward := &serverproto.RankRewardList{
				RushType:data.Key,
			}
			if data.Key == model.Rush_Type_Tower {
				rankMode.TowerMag.GetRushReward(msg.Uid, data.Value, reward)
			} else if data.Key == model.Rush_Type_Arena {
				rankMode.ArenaMag.GetRushReward(msg.Uid, data.Value, reward)
			} else if data.Key == model.Rush_Type_Map {
				rankMode.MapScoreMag.GetRushReward(msg.Uid, data.Value, reward)
			} else if data.Key == model.Rush_Type_Pet {
				rankMode.PetRankMag.GetRushReward(msg.Uid, data.Value, reward)
			} else if data.Key == model.Rush_Type_Skill {
				rankMode.SkillRankMag.GetRushReward(msg.Uid, data.Value, reward)
			}

			ackMsg.RewardList = append(ackMsg.RewardList, reward)
		}
		model.ServiceReplay(ev, ackMsg)
	})

	//主动领取排名奖励请求
	/*
	serverproto.Handle_RANK_SSGetRushRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSGetRushRankReq)
		util.DebugF("uid=%v receive SSGetRushRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSGetRushRankAck{
			Uid:      msg.Uid,
			RushType: msg.RushType,
		}
		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.GetRushReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.GetRushReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Map {
			rankMode.MapScoreMag.GetRushReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.GetRushReward(msg.Uid, msg.RushRound, ackMsg)
		} else if msg.RushType == model.Rush_Type_Skill {
			rankMode.SkillRankMag.GetRushReward(msg.Uid, msg.RushRound, ackMsg)
		}
		model.ServiceReplay(ev, ackMsg)
	})
	 */

	//主动领取排名奖励请求
	serverproto.Handle_RANK_SSTestRushRankRewardNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSTestRushRankRewardNtf)
		util.DebugF("uid=%v receive SSTestRushRankRewardNtf msg=%v", cliId.SessID, msg)

		if msg.RushType == model.Rush_Type_Tower {
			rankMode.TowerMag.SendRushTowerReward()
		} else if msg.RushType == model.Rush_Type_Arena {
			rankMode.ArenaMag.SendRushArenaReward()
		} else if msg.RushType == model.Rush_Type_Map{
			rankMode.MapScoreMag.SendRushMapReward()
		} else if msg.RushType == model.Rush_Type_Pet {
			rankMode.PetRankMag.SendRushPetReward()
		}
	})

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

		rankMode.MapScoreMag.AddMapScoreRank(msg.Uid, msg.Score)
	})

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

		rankMode.KeepSakeMag.OnKeepSakeCollectChange(msg.Uid, msg.KeepSakeId)
	})

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

		rankMode.KeepSakeMag.KeepSakeRankInfo(msg, ev)
	})

	//精彩活动获取全局数据
	serverproto.Handle_RANK_SSActivitiesCollectionServerDataReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSActivitiesCollectionServerDataReq)
		util.DebugF("uid=%v SSActivitiesCollectionServerDataReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSActivitiesCollectionServerDataAck{
			ActivityId: msg.ActivityId,
			RewardIdx:  msg.RewardIdx,
			PetData:    msg.PetData,
		}
		//清空全局数据方式不用通知
		if rankMode.GetActivitiesCollectionData(msg.ActivityId, msg.RewardIdx, msg.ServerLimitNum, ssAckMsg) {
			model.ServiceReplay(ev, ssAckMsg)
		}
	})

	//勇士积分排行榜
	//积分更新
	serverproto.Handle_RANK_SSExpeditionUpdateScoreRankNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionUpdateScoreRankNtf)
		util.DebugF("uid=%v receive SSExpeditionUpdateScoreRankNtf msg=%v", cliId.SessID, msg)

		rankMode.UpdateExpeditionScoreRank(msg.CurScore, cliId.SessID)
	})
	//获取排行榜
	serverproto.Handle_RANK_SSExpeditionScoreRankListReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSExpeditionScoreRankListReq)
		util.DebugF("uid=%v receive SSExpeditionScoreRankListReq msg=%v", cliId.SessID, msg)

		ssAckMsg := &serverproto.SSExpeditionScoreRankListAck{
			Error:    int32(serverproto.ErrorCode_ERROR_OK),
			StartIdx: msg.StartIdx,
		}
		rankMode.ExpeditionScoreRank(msg.StartIdx, ssAckMsg, cliId.SessID)

		model.ServiceReplay(ev, ssAckMsg)
	})


	//更新宠物战力排行榜，更新上阵宠物
	serverproto.Handle_RANK_SSRushPetInfoChangeNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRushPetInfoChangeNtf)
		util.DebugF("uid=%v receive SSRushPetInfoChangeNtf msg=%v", cliId.SessID, msg)

		rankMode.PetRankMag.RefreshRushPetData(msg)
	})

	//请求宠物冲榜后续数据
	serverproto.Handle_RANK_CSPetActivityRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSPetActivityRankReq)
		util.DebugF("uid=%v receive CSPetActivityRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SCPetActivityRankAck {
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			Page:  msg.Page,
		}

		ackMsg.Error = int32(rankMode.PetRankMag.GetRushPetRankInfo(msg.Page, ackMsg))

		model.ServiceReplay(ev, ackMsg)
	})

	//更新技能排行
	serverproto.Handle_RANK_SSRushSkillInfoChangeNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSRushSkillInfoChangeNtf)
		util.DebugF("uid=%v receive SSRushSkillInfoChangeNtf msg=%v", cliId.SessID, msg)

		rankMode.SkillRankMag.RefreshRushSkillData(msg)
	})

	//请求技能冲榜后续数据
	serverproto.Handle_RANK_CSRushSkillActivityRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.CSRushSkillActivityRankReq)
		util.DebugF("uid=%v receive CSRushSkillActivityRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SCRushSkillActivityRankAck {
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			Page:  msg.Page,
		}

		ackMsg.Error = int32(rankMode.SkillRankMag.GetRushSkillRankInfo(msg.Page, ackMsg))

		model.ServiceReplay(ev, ackMsg)
	})

	//偶像季，请求自己的粉丝列表
	serverproto.Handle_RANK_SSCompetitionSelfFansInfoReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionSelfFansInfoReq)
		util.DebugF("uid=%v receive SSCompetitionSelfFansInfoReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSCompetitionSelfFansInfoAck {
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			Uid: msg.Uid,
		}

		ackMsg.Error = int32(rankMode.CompetitionMag.GetSelfFansInfo(msg.Uid, msg.CompetitionId, ackMsg))
		model.ServiceReplay(ev, ackMsg)
	})
	//请求技能冲榜后续数据
	serverproto.Handle_RANK_SSCompetitionVoteRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionVoteRankReq)
		util.DebugF("uid=%v receive SSCompetitionVoteRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSCompetitionVoteRankAck{
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			Page:  msg.Page,
			Uid:   msg.Uid,
			IsEnd: false,
		}
		ackMsg.Error = int32(rankMode.CompetitionMag.GetVoteRank(msg.Page, msg.CompetitionId, ackMsg))
		model.ServiceReplay(ev, ackMsg)
	})
	//偶像季请求偶像馈赠排名
	serverproto.Handle_RANK_SSCompetitionFansRewardRankReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansRewardRankReq)
		util.DebugF("uid=%v receive SSCompetitionFansRewardRankReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSCompetitionFansRewardRankAck{
			Error: int32(serverproto.ErrorCode_ERROR_FAIL),
			Page:  msg.Page,
			IsEnd: false,
		}
		ackMsg.Error = int32(rankMode.CompetitionMag.GetFansRewardRankInfo(msg.Page, msg.CompetitionId, ackMsg))
		model.ServiceReplay(ev, ackMsg)
	})
	//偶像季，粉丝请求领取偶像馈赠宝箱
	serverproto.Handle_RANK_SSCompetitionFansGetRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansGetRewardReq)
		util.DebugF("uid=%v receive SSCompetitionFansGetRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSCompetitionFansGetRewardAck{
			Error:       int32(serverproto.ErrorCode_ERROR_FAIL),
			Uid:         msg.Uid,
			RewardLevel: msg.RewardLevel,
			IdolUid:     msg.IdolUid,
		}
		bRet, score := rankMode.CompetitionMag.GetSingleFansRewardData(msg.IdolUid, msg.CompetitionId)
		ackMsg.Error = int32(bRet)
		ackMsg.IdolBoxCount = score
		model.ServiceReplay(ev, ackMsg)
	})

	//偶像季，购买宝箱更新馈赠排名
	serverproto.Handle_RANK_SSCompetitionAddIdolBoxScoreNtf = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionAddIdolBoxScoreNtf)
		util.DebugF("uid=%v receive SSCompetitionAddIdolBoxScoreNtf msg=%v", cliId.SessID, msg)

		rankMode.CompetitionMag.AddIdolBoxScore(msg.Uid, msg.Score, msg.CompetitionId)
	})

	//偶像季，赛季结束，给玩家发送奖励
	serverproto.Handle_RANK_SSCompetitionFansGetAllRewardReq = model.HandleBackendMessage(func(ev rocommon.ProcEvent, cliId model.ClientID) {
		msg := ev.Msg().(*serverproto.SSCompetitionFansGetAllRewardReq)
		util.DebugF("uid=%v receive SSCompetitionFansGetAllRewardReq msg=%v", cliId.SessID, msg)

		ackMsg := &serverproto.SSCompetitionFansGetAllRewardAck{
			CompetitionId:    msg.CompetitionId,
			CompetitionSubId: msg.CompetitionSubId,
		}
		rankMode.CompetitionMag.GetAllFansReward(msg, ackMsg)
		model.ServiceReplay(ev, ackMsg)
	})

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

		ackMsg := &serverproto.SSCompetitionGetPlayerVoteRankAck{
			Error:  int32(serverproto.ErrorCode_ERROR_FAIL),
			ReqUid: msg.ReqUid,
		}
		bRet := rankMode.CompetitionMag.GetIdolRankData(msg.Uid, msg.CompetitionId, ackMsg)
		ackMsg.Error = int32(bRet)
		model.ServiceReplay(ev, ackMsg)
	})
}