local Player_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local common_pb = require 'Proto/common_pb'
local hero_oper_pb = require 'Proto/hero_oper_pb'
local energyValue = 0
local energyInfo = nil
local other_info_pb = require 'Proto.other_info_pb'

local WEAR_STATE_OLD_KEY = "WearViewToggleState_%s_%d"
local WEAR_STATE_KEY = "WearViewToggleState"

--养成系统（装备、坐骑、宝物等）穿戴/替换界面内的toggle状态枚举
Player_Model.WearViewToggleStateType = {
    EquipWear = 1,
    EquipChange = 2,
    HorseWear = 3,
    HorseChange = 4,
    TreasureWear = 5,
    TreasureChange = 6,
    HeroChange = 7, --切换武将
    AssistanceChange = 8, --切换助战
    PetChange = 9,
}

private.wearViewToggleStateTypeDic = {}

private.gsContext = {}

function Player_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageHeroShowChange, private.ShowChangeHeroResponse)
    NetManager.RegisterMsgCB(MessageEnums.MessageOtherPeopleInfo, private.OnOtherPeopleResp)

    private.G2CPushPlayerChangeRegister()
    private._currentLineUpGs = 0
    private._gender = nil
end

function Player_Model.GetSelfGender()
    return private._gender
end

function Player_Model.SetSelfGender(gender)
    private._gender = gender
end

function Player_Model.ShowChangeHeroRequest(id)
    local msg = hero_oper_pb.HeroShowChangeReq()
    msg.HeroId = id
    NetManager.SendMessage(MessageEnums.MessageHeroShowChange, msg)
end

function private.ShowChangeHeroResponse(msgResp)
    logging.log(LTAG.LOG, "ShowChangeHeroResponse", msgResp.Resp.PlayerChange.baseInfo.HeroId)
    if msgResp.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_Team_ChangeHint_7)
        Player_Model.SetCurShowId(msgResp.Resp.PlayerChange.baseInfo.HeroId)
        EventSystem.Dispatch(EventID.ChangeTeamShowModel)
    end
end

function Player_Model.GetEnergyValue(  )
    return energyInfo and energyInfo.Count or 0
end

function Player_Model.GetEnergyInfo(  )
    return energyInfo
end

function Player_Model.SetEnergyInfo(info, isInit)
    energyInfo = info
    CTL.Player.AddEnergy(energyInfo)
    MDL.EnergyGet.SetEnergyGetState(info.energyGetState)
    EventSystem.Dispatch(EventID.UI_Energy_Refresh)
end

function Player_Model.GetNextEnergyTime()
    if energyInfo then
        if energyInfo.Count >= DataSheetManager.ConstData:GetDataByID("MaxEnergy").IntValue then 
            return 0
        end
        local value = MDL.Player.GetEnergyInfo().energyRestoreTime + DataSheetManager.ConstData:GetDataByID("RestoreEnergyTime").IntValue
        return value - UTL.Time.GetServerTimestamp()
    else
        --正常情况，比如战斗回放
        return 0
    end
end

--region -- **************** 数据操作 ******************* --
function private.UpdatePlayerChange(playerChange, msgId)
    if not IsProtoDataNotNil(playerChange) then
        return
    end

    if IsServerDataNotNil(playerChange.energyInfo) then
        xpcall(Player_Model.SetEnergyInfo, private.PlayerChangeErrorMsg, playerChange.energyInfo)
    end
    --角色信息
    if IsServerDataNotNil(playerChange.RoleInfo) then
        if not (playerChange.RoleInfo.TeamLevel==0 and playerChange.RoleInfo.TeamLevelExp==0 and playerChange.RoleInfo.TeamRankID==0) then
            xpcall(CTL.Player.UpdateRoleInfo, private.PlayerChangeErrorMsg, playerChange.RoleInfo)
        end
    end
    --获取主将及经验等级变化
    local isHeroChange = false
    if IsServerDataNotNil(playerChange.UpdateHeroes) then
        isHeroChange = true
        xpcall(MDL.HeroSelect.UpdateHeros, private.PlayerChangeErrorMsg, playerChange.UpdateHeroes)
        if IsServerDataNotNil(playerChange.allHeroAttrInfos) then
            logging.log(LTAG.LOG, "武将信息全部信息和属性信息同时更新，除了共鸣之外理论上不应该出现，请客户端和服务器排查！！！")
            xpcall(MDL.HeroSelect.UpdateHeroAttrInfo, private.PlayerChangeErrorMsg, playerChange.allHeroAttrInfos)
        end
    else --如果同时出现，有可能是因为某些问题，这个时候优先使用武将的全部信息进行更新。
        if IsServerDataNotNil(playerChange.allHeroAttrInfos) then
            xpcall(MDL.HeroSelect.UpdateHeroAttrInfo, private.PlayerChangeErrorMsg, playerChange.allHeroAttrInfos)
        end
    end
    --获取上阵武将和战力相关
    if IsServerDataNotNil(playerChange.HeroLineUp) then
        xpcall(Player_Model.SetHeroLineUpInfo, private.PlayerChangeErrorMsg, playerChange.HeroLineUp.LineUpHeroIds, playerChange.HeroLineUp.LineUpHeroGs, playerChange.HeroLineUp.ThreeTeamGs)
        xpcall(Player_Model.UpdateLineUpGs, private.PlayerChangeErrorMsg, playerChange.HeroLineUp.LineUpGs, false)
        xpcall(MDL.Formation.UpdateSlotHeroIds, private.PlayerChangeErrorMsg, playerChange.HeroLineUp.FormationSlotHeroIds)
    elseif isHeroChange then
        xpcall(Player_Model.UpdateHeroInfDict, private.PlayerChangeErrorMsg, Player_Model.GetHeroLinUpIds())
    end
    
    if IsServerDataNotNil(playerChange.privilegeInfo) then
        xpcall(MDL.OfficialPrivilege.SyncPrivilegeInfo, private.PlayerChangeErrorMsg, playerChange.privilegeInfo)
    end

    if IsServerDataNotNil(playerChange.officialInfo) then
        xpcall(MDL.OfficialPosition.SyncOfficialInfo, private.PlayerChangeErrorMsg, playerChange.officialInfo, false)
    end
    if IsServerDataNotNil(playerChange.baseInfo) then
        xpcall(Player_Model.SetRoleId, private.PlayerChangeErrorMsg, playerChange.baseInfo.player_id)
        xpcall(MDL.Name.SetLastNamedTime, private.PlayerChangeErrorMsg, playerChange.baseInfo.lastNamedTime)
        xpcall(MDL.Name.SetNamedFreeNums, private.PlayerChangeErrorMsg, playerChange.baseInfo.NamedFreeNums)
        xpcall(CTL.Notification.InitNotification, private.PlayerChangeErrorMsg, playerChange.baseInfo.appPushRewardState)
        xpcall(MDL.MonthCard.SetHadAllMonthCardActive, private.PlayerChangeErrorMsg, playerChange.baseInfo.hadAllMonthCardActive)
    end

    if IsServerDataNotNil(playerChange.changedLevelInfos) then
        xpcall(MDL.LevelSelect.UpdateStoryInfo, private.PlayerChangeErrorMsg, playerChange.changedLevelInfos)
    end
    xpcall(MDL.ChannelChat.SetFirstPassLevelForNew, private.PlayerChangeErrorMsg, playerChange.guideStep)

    if IsServerDataNotNil(playerChange.fighterInfo) then
        xpcall(MDL.SyncTeamPVP.InitFighterProperties, private.PlayerChangeErrorMsg, playerChange.fighterInfo)
    end
    -- 包裹增加或更新物品
    if IsServerDataNotNil(playerChange.BagAddUpdate) then
        --optional BagInfo BagAddUpdate = 2; // 包裹增加或更新物品
        xpcall(MDL.Bag.UpdateOrAddBagInfo, private.PlayerChangeErrorMsg, msgId, playerChange.BagAddUpdate)
        --碎片
        if IsProtoDataNotNil(playerChange.BagAddUpdate.equipShreds) then
            xpcall(MDL.Equipment.UpdateOrAddEquipDebris, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.equipShreds)
        end
        --宝石
        if IsProtoDataNotNil(playerChange.BagAddUpdate.jewelry) then
            xpcall(MDL.GemCompose.UpdateGemFromBag, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.jewelry)
        end
        --魂晶
        if IsProtoDataNotNil(playerChange.BagAddUpdate.soulCrystals) or IsProtoDataNotNil(playerChange.BagAddUpdate.soulCrystalExtras) then
            xpcall(MDL.Treasure.UpdateBagSoulCrystal, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.soulCrystals, playerChange.BagAddUpdate.soulCrystalExtras)
        end
        --魂珠
        if IsProtoDataNotNil(playerChange.BagAddUpdate.soulPearls) or IsProtoDataNotNil(playerChange.BagAddUpdate.soulPearlExtras) then
            xpcall(MDL.HorseSoul.UpdateBagSoulPearl, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.soulPearls, playerChange.BagAddUpdate.soulPearlExtras)
        end
        --英雄置换道具额外信息
        if IsProtoDataNotNil(playerChange.BagAddUpdate.heroSubstituteItemExtra) then
            xpcall(MDL.Bag.UpdateBagHeroSubstituteItemExtra, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.heroSubstituteItemExtra)
        end
        --宠物符文
        if IsProtoDataNotNil(playerChange.BagAddUpdate.petTalismans) then
            xpcall(MDL.Pet.SetBagRune, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.petTalismans, false)
        end
        --战装
        if IsProtoDataNotNil(playerChange.BagAddUpdate.horseEquip) then
            xpcall(MDL.HorseEquip.UpdateEquipBag, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.horseEquip)
        end
    end
    --包裹删除物品
    if IsServerDataNotNil(playerChange.BagDel) then
        --	optional DelBagInfo BagDel = 3; // 包裹删除物品
        xpcall(MDL.Bag.DeleteBagInfo, private.PlayerChangeErrorMsg, msgId, playerChange.BagDel)
        --装备
        if IsProtoDataNotNil(playerChange.BagDel.equips) then
            xpcall(MDL.Equipment.DeleteEquip, private.PlayerChangeErrorMsg, playerChange.BagDel.equips)
        end
        --碎片
        if IsProtoDataNotNil(playerChange.BagDel.equipShreds) then
            xpcall(MDL.Equipment.DeleteEquipDebris, private.PlayerChangeErrorMsg, playerChange.BagDel.equipShreds)
        end
        --宝石
        if IsProtoDataNotNil(playerChange.BagDel.jewelry) then
            xpcall(MDL.GemCompose.DelGemFromBag, private.PlayerChangeErrorMsg, playerChange.BagDel.jewelry)
        end
        --魂晶
        if IsProtoDataNotNil(playerChange.BagDel.soulCrystals) then
            xpcall(MDL.Treasure.DelBagSoulCrystal, private.PlayerChangeErrorMsg, playerChange.BagDel.soulCrystals)
        end
        --魂珠
        if IsProtoDataNotNil(playerChange.BagDel.soulPearls) then
            xpcall(MDL.HorseSoul.DelBagSoulPearl, private.PlayerChangeErrorMsg, playerChange.BagDel.soulPearls)
        end
        --宠物符文
        if IsProtoDataNotNil(playerChange.BagDel.petTalismans) then
            xpcall(MDL.Pet.DelBagPetRune, private.PlayerChangeErrorMsg, playerChange.BagDel.petTalismans)
        end
        --战装
        if IsProtoDataNotNil(playerChange.BagDel.horseEquip) then
            xpcall(MDL.HorseEquip.DelHorseEquipBag, private.PlayerChangeErrorMsg, playerChange.BagDel.horseEquip)
        end
    end
    --武将列传信息更新
    if IsServerDataNotNil(playerChange.heroBiography) then
        xpcall(MDL.Biography.SetBiographyInfoMsg, private.PlayerChangeErrorMsg, playerChange.heroBiography)
    end

    if IsServerDataNotNil(playerChange.SCInfos) then
        xpcall(MDL.Currency.UpdateSoftTokenList, private.PlayerChangeErrorMsg, msgId, playerChange.SCInfos, false)
    end
    if IsServerDataNotNil(playerChange.HCInfos) then
        xpcall(MDL.Currency.UpdateHardTokenList, private.PlayerChangeErrorMsg, msgId, playerChange.HCInfos, false)
    end
    -- 红点列表
    if IsServerDataNotNil(playerChange.redPoints) then
        xpcall(MDL.RedPoint.UpdateEnterWorldRedPointList, private.PlayerChangeErrorMsg, playerChange.redPoints)
    end
    --新增装备或者主将变化
    if IsServerDataNotNil(playerChange.BagAddUpdate) then
        --强化装备，这里面数据都是空，但是靠这个刷新强化界面，因此暂时不能判空
        if IsProtoDataNotNil(playerChange.BagAddUpdate.equips) or IsProtoDataNotNil(playerChange.BagAddUpdate.equipExtras) then
            xpcall(MDL.Equipment.UpdateOrAddEquip, private.PlayerChangeErrorMsg, playerChange.BagAddUpdate.equips, playerChange.BagAddUpdate.equipExtras)
        end
    end

    --坐骑信息变化或者主将穿戴/替换坐骑
    if IsServerDataNotNil(playerChange.horseInfoList) or IsServerDataNotNil(playerChange.UpdateHeroes) then
        xpcall(MDL.WarHorse.SyncHorseInfo, private.PlayerChangeErrorMsg, playerChange.horseInfoList, playerChange.UpdateHeroes, playerChange.changeTypeInfo)
    end
    -- 坐骑魂珠-聚魂（抽卡）
    if IsServerDataNotNil(playerChange.drawHorseSoulInfo) then
        xpcall(MDL.HorseSoul.SyncDrawHorseSoulInfo, private.PlayerChangeErrorMsg, playerChange.drawHorseSoulInfo)
    end
    --宝物信息变化或者主将穿戴/替换宝物
    if IsServerDataNotNil(playerChange.treasureInfo) or IsServerDataNotNil(playerChange.UpdateHeroes) then
        xpcall(MDL.Treasure.UpdateActiveTreasureInfo, private.PlayerChangeErrorMsg, msgId, playerChange.treasureInfo, playerChange.UpdateHeroes)
    end
    --爬塔信息
    if IsServerDataNotNil(playerChange.climbTowerInfos) then
        xpcall(MDL.ClimbTower.SyncClimbTowerInfo, private.PlayerChangeErrorMsg, playerChange.climbTowerInfos)
    end
    --四国爬塔信息
    if IsServerDataNotNil(playerChange.fourNationTowerInfo) then
        xpcall(MDL.NationClimbTower.SyncFourNationClimbTowerInfo, private.PlayerChangeErrorMsg, playerChange.fourNationTowerInfo, false)
    end
    
    --世界Boss
    if IsServerDataNotNil(playerChange.worldbossInfo) then
        xpcall(MDL.WorldBoss.SyncWorldBossInfo, private.PlayerChangeErrorMsg, playerChange.worldbossInfo)
    end

    -- 战区Boss
    if IsServerDataNotNil(playerChange.warZoneBossInfo) then
        xpcall(MDL.CountryWorldBoss.SyncCountryWorldBossBossInfo, private.PlayerChangeErrorMsg, playerChange.warZoneBossInfo)
    end

    --个人Boss
    if IsServerDataNotNil(playerChange.personalBossInfo) then
        xpcall(MDL.PersonalBoss.SyncPersonalBossInfo, private.PlayerChangeErrorMsg, playerChange.personalBossInfo)
    end

    -- 魔神
    if IsServerDataNotNil(playerChange.demonGodInfo) then
        xpcall(MDL.DemonGod.EnterDemonGodInfoRequest, private.PlayerChangeErrorMsg, playerChange.demonGodInfo)
    end

    --组队副本奖励次数
    if IsServerDataNotNil(playerChange.teamPVEInfo) then
        xpcall(MDL.TeamDungeon.SyncLeftAwardCount, private.PlayerChangeErrorMsg, playerChange.teamPVEInfo)
    end

    --环任务次数
    if IsServerDataNotNil(playerChange.ringTaskNum) then
        xpcall(MDL.Task.SetRingRound, private.PlayerChangeErrorMsg, playerChange.ringTaskNum)
    end
    --叛军突袭奖励次数
    if IsServerDataNotNil(playerChange.rebelStrikeInfo) then
        xpcall(MDL.RebelStrike.SyncAwardTimes, private.PlayerChangeErrorMsg, playerChange.rebelStrikeInfo)
    end

    --首充
    if IsServerDataNotNil(playerChange.firstChargeGiftInfo) then
        xpcall(MDL.FirstCharge.SyncFirstChargeInfo, private.PlayerChangeErrorMsg, playerChange.firstChargeGiftInfo)
    end

    --活动活跃度信息
    if IsServerDataNotNil(playerChange.activityInfo) then
        xpcall(MDL.Activities.SetActiveData, private.PlayerChangeErrorMsg, playerChange.activityInfo)
    end

    if IsServerDataNotNil(playerChange.serverDay) then
        xpcall(Player_Model.SetServerDay, private.PlayerChangeErrorMsg, playerChange.serverDay)
    end

    if IsServerDataNotNil(playerChange.soloFightInfo) then
        xpcall(MDL.SoloFight.SetSoloFightInfo, private.PlayerChangeErrorMsg, playerChange.soloFightInfo)
    end

    if IsServerDataNotNil(playerChange.capitalBuffInfos) then
        xpcall(MDL.HomeMain.SyncCapitalBuff, private.PlayerChangeErrorMsg, playerChange.capitalBuffInfos)
    end

    --抽卡系统
    if IsServerDataNotNil(playerChange.drawCardInfo) then
        xpcall(MDL.DrawCard.RefreshCardInfoByServer, private.PlayerChangeErrorMsg, playerChange.drawCardInfo)
    end
    
    if IsServerDataNotNil(playerChange.storeInfos) then
        xpcall(MDL.PayMall.SetStoreInfos, private.PlayerChangeErrorMsg, playerChange.storeInfos)
	end
	
    if IsServerDataNotNil(playerChange.finishedGuide) then
        xpcall(MDL.PlayerGuide.SetFinishInfo, private.PlayerChangeErrorMsg, playerChange.finishedGuide)
    end

    if IsServerDataNotNil(playerChange.rechargeInfo) then
        xpcall(MDL.Currency.SyncRechargeAmount, private.PlayerChangeErrorMsg, playerChange.rechargeInfo)
    end

    if IsServerDataNotNil(playerChange.resourceLevelInfo) then
        xpcall(MDL.MaterialLevel.SetInfo, private.PlayerChangeErrorMsg, playerChange.resourceLevelInfo)
    end

    if IsServerDataNotNil(playerChange.guildInfo) then
        xpcall(MDL.Guild.SetMyGuildInfo, private.PlayerChangeErrorMsg, msgId, playerChange.guildInfo)
    end

    if IsServerDataNotNil(playerChange.onlineRewardInfo) then
        xpcall(MDL.OnlineReward.SetOnlineRewardInfo, private.PlayerChangeErrorMsg, playerChange.onlineRewardInfo)
    end

    --运营活动玩家信息
    if IsServerDataNotNil(playerChange.operationActivityInfo) then
        xpcall(MDL.OperationActivity.SetOAInfo, private.PlayerChangeErrorMsg, nil, playerChange.operationActivityInfo)
    end
    
    if IsServerDataNotNil(playerChange.functionRewardInfo) then
        xpcall(MDL.FunctionNotice.SyncAwardInfo, private.PlayerChangeErrorMsg, playerChange.functionRewardInfo)
    end

    --阵位共鸣
    if IsServerDataNotNil(playerChange.resonanceInfo) then
        xpcall(MDL.FormationResonance.SetResonanceInfo, private.PlayerChangeErrorMsg, playerChange.resonanceInfo, true)
    end
    
    --多人副本
    if IsServerDataNotNil(playerChange.playerDungeonInfo) then
        xpcall(MDL.MultiplayerDungeon.SyncMultiplayerDungeonInfo, private.PlayerChangeErrorMsg, playerChange.playerDungeonInfo)
    end

    --拍卖行
    xpcall(MDL.GuildAuction.SetShowGuildAuctionTypes, private.PlayerChangeErrorMsg, playerChange.personalAuctionHouse)

    --成就
    xpcall(MDL.Achievement.SetAchievementInfos, private.PlayerChangeErrorMsg, playerChange.achievementSystemInfo)

    --region ************** 福利 **************
    --每日礼包
    if IsServerDataNotNil(playerChange.dailyGift) then
        xpcall(MDL.DailyGift.SyncDailyGiftInfo, private.PlayerChangeErrorMsg, playerChange.dailyGift)
    end
    --月卡
    if IsServerDataNotNil(playerChange.monthCardInfos) then
        xpcall(MDL.MonthCard.SetMonthCardInfo, private.PlayerChangeErrorMsg, playerChange.monthCardInfos)
    end
    -- 基金
    if IsServerDataNotNil(playerChange.fundInfos) then
        xpcall(MDL.GrowthFund.SyncFundInfo, private.PlayerChangeErrorMsg, playerChange.fundInfos)
    end
    -- 名将之路
    if IsServerDataNotNil(playerChange.heroFundInfo) then
        xpcall(MDL.HeroFund.SyncHeroFundInfo, private.PlayerChangeErrorMsg, playerChange.heroFundInfo)
    end
    -- 奖励找回
    if IsServerDataNotNil(playerChange.resourceInfos) then
        xpcall(MDL.RewardsRetrieve.SyncRewardRecoveryInfo, private.PlayerChangeErrorMsg, playerChange.resourceInfos)
    end
    -- 充值返利变化
    if IsServerDataNotNil(playerChange.payRewardInfo) then
        xpcall(MDL.RechargeReturn.UpdateRechargeReturnCount, private.PlayerChangeErrorMsg, playerChange.payRewardInfo)
    end
    -- 每日签到
    if IsServerDataNotNil(playerChange.dailySigninInfo) then
        xpcall(MDL.DailySignin.SyncSigninInfo, private.PlayerChangeErrorMsg, playerChange.dailySigninInfo)
    end
    -- 预约豪礼，服务器下发是否弹窗
    xpcall(MDL.ReservedGift.SyncReservedGiftState, private.PlayerChangeErrorMsg, playerChange.reservedGiftState)
    -- 大包更新
    if not GameAppInfo.IsChinesePackage() then
        xpcall(MDL.VersionUpdate.SetUpdateInfos, private.PlayerChangeErrorMsg, playerChange.versionUpdateInfo)
    end
    -- 月累充
    xpcall(MDL.DrawStraws.RefreshDrawStrawsInfos, private.PlayerChangeErrorMsg, playerChange.drawStrawsInfos)
    -- 休沐祭礼
    if IsServerDataNotNil(playerChange.weekendRewardInfo) then
        xpcall(MDL.WeekendReward.SyncWeekendRewardInfo, private.PlayerChangeErrorMsg, playerChange.weekendRewardInfo)
    end
    --endregion ************** 福利 **************

    --称号
    if IsServerDataNotNil(playerChange.titleInfos) then
        xpcall(MDL.Title.SyncTitleInfo, private.PlayerChangeErrorMsg, playerChange.titleInfos, false)
    end
    
    if IsServerDataNotNil(playerChange.guildPartyInfo) then
        xpcall(MDL.GuildParty.SetLeftActivityExpTimes, private.PlayerChangeErrorMsg, playerChange.guildPartyInfo)
    end

    --进爵
    if IsServerDataNotNil(playerChange.nobilityStage) then
        xpcall(MDL.Nobility.PlayerChangeSyncNobilityInfo, private.PlayerChangeErrorMsg, playerChange.nobilityStage.StageDone)
    end

    --势力共建
    if IsServerDataNotNil(playerChange.guildTargetInfo) then
        xpcall(MDL.GuildTarget.ChangeGuildTargetData, private.PlayerChangeErrorMsg, playerChange.guildTargetInfo)
    end
    
    -- 等级礼包
    if IsProtoDataNotNil(playerChange.levelGiftInfo) then
        xpcall(MDL.Reward.UpdateLevelGiftClaim, private.PlayerChangeErrorMsg, playerChange.levelGiftInfo)
    end

    -- 助战
    if IsServerDataNotNil(playerChange.assistanceData) then
        xpcall(MDL.AssistanceFight.SetSlotInfos, private.PlayerChangeErrorMsg, playerChange.assistanceData.slotInfos)
        xpcall(MDL.AssistanceFight.SetFormationSlotHeroAttrDatas, private.PlayerChangeErrorMsg, playerChange.assistanceData.lineups)
    end
    -- 非上阵非助战武将属性推送
    if IsServerDataNotNil(playerChange.assHeroChange) then
        xpcall(MDL.AssistanceFight.SetFormationSlotHeroAttrDatas, private.PlayerChangeErrorMsg, playerChange.assHeroChange, true)
    end
    
    --图鉴
    if IsServerDataNotNil(playerChange.pictorialBookInfo) then
        --武将图鉴
        xpcall(MDL.HeroLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        --神兵图鉴
        xpcall(MDL.WeaponLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        --坐骑图鉴
        xpcall(MDL.HorseLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        --宝物图鉴
        xpcall(MDL.TreasureLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        --计略图鉴
        xpcall(MDL.StratagemLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo, playerChange.stratagemPictorialInfo)
        -- 神兽图鉴
        xpcall(MDL.GodBeastLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        --光效图鉴
        xpcall(MDL.EffectLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        xpcall(MDL.DyeLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
        xpcall(MDL.AppearanceLibrary.SetLibraryInfo, private.PlayerChangeErrorMsg, playerChange.pictorialBookInfo)
    end
   
    --藏宝图副本信息
    if IsServerDataNotNil(playerChange.digTreasureRewardInfo) then
        xpcall(MDL.Task.SetTreasureRewardInfo, private.PlayerChangeErrorMsg, playerChange.digTreasureRewardInfo)
    end

    --大乱斗信息
    if IsServerDataNotNil(playerChange.fightThroneInfo) then
        xpcall(MDL.FightThrone.SyncFightThroneInfo, private.PlayerChangeErrorMsg, playerChange.fightThroneInfo)
    end

    --龙脉战
    if IsServerDataNotNil(playerChange.dragonEnterInfo) then
        xpcall(MDL.DragonArtery.SyncEnterInfo, private.PlayerChangeErrorMsg, playerChange.dragonEnterInfo)
    end

    --region ********** 金将体验关 ********
    --金将体验关专属体力
    if IsServerDataNotNil(playerChange.goldHeroEnergy) then
        xpcall(MDL.GoldenHeroMain.SetGoldHeroEnergyInfo, private.PlayerChangeErrorMsg, playerChange.goldHeroEnergy)
    end
    --金将体验关累积消耗
    if IsServerDataNotNil(playerChange.activityStores) then
        xpcall(MDL.GoldenHeroMain.SetActivityConsumeList, private.PlayerChangeErrorMsg, playerChange.activityStores)
    end
    --金将体验关——秘闻
    if IsServerDataNotNil(playerChange.goldHeroSecretInfos) then
        xpcall(MDL.GoldenHeroStory.SyncPullGoldHeroSecretInfo, private.PlayerChangeErrorMsg, playerChange.goldHeroSecretInfos)
    end
    --金将体验关——秘闻
    if IsServerDataNotNil(playerChange.goldHeroOpenStory) then
        xpcall(MDL.GoldenHeroStory.GoldHeroOpenStoryChange, private.PlayerChangeErrorMsg, playerChange.goldHeroOpenStory)
    end
    --金将轶事信息
    if IsServerDataNotNil(playerChange.GoldHeroAnecdotes) then
        xpcall(MDL.GoldenHeroAnecdote.RefreshAnecdoteInfo, private.PlayerChangeErrorMsg, playerChange.GoldHeroAnecdotes)
    end
    --endregion ********** 金将体验关 ********

    --彩金将--体验关结局数据
    if IsServerDataNotNil(playerChange.superGoldHeroEnding) then
        xpcall(MDL.SuperGoldStory.SuperGoldHeroOpenStoryChange, private.PlayerChangeErrorMsg, playerChange.superGoldHeroEnding)
    end

    --累充礼包信息
    if IsServerDataNotNil(playerChange.multilevelChargeGiftInfo) then
        xpcall(MDL.MultilevelRecharge.SetMultilevelChargeGiftInfo, private.PlayerChangeErrorMsg, playerChange.multilevelChargeGiftInfo)
    end

    --红包领取消息
    if IsServerDataNotNil(playerChange.redEnvelopChange) then
        xpcall(MDL.RedPacket.SyncRedPacketReceiveTimesAndRedPoint, private.PlayerChangeErrorMsg, playerChange.redEnvelopChange)
    end

    --武将时装
    if IsServerDataNotNil(playerChange.appearanceInfos) then
        xpcall(MDL.Appearance.SyncRefreshAppearanceList, private.PlayerChangeErrorMsg, playerChange.appearanceInfos)
    end
	
	--战区变更，切换聊天服
    xpcall(MDL.ChannelChat.SyncWarZoneId, private.PlayerChangeErrorMsg, playerChange.warZoneId)

    if IsServerDataNotNil(playerChange.addInfoReminds) then
        xpcall(MDL.InfoReminder.AddInfoReminds, private.PlayerChangeErrorMsg, playerChange.addInfoReminds)
    end
    
    if IsServerDataNotNil(playerChange.delInfoRemindIds) then
        xpcall(MDL.InfoReminder.DelInfoRemindIds, private.PlayerChangeErrorMsg, playerChange.delInfoRemindIds)
    end

    --排行榜点赞信息
    if IsServerDataNotNil(playerChange.RankThumbsUpInfo) then
        xpcall(MDL.Rank.SyncRankThumbsUpInfo, private.PlayerChangeErrorMsg, playerChange.RankThumbsUpInfo)
    end

    --神兵锻造
    if IsServerDataNotNil(playerChange.foundryActivateInfo) then
        xpcall(MDL.DivineWeapon.SetForgeInfos, private.PlayerChangeErrorMsg, playerChange.foundryActivateInfo)
    end

    --定时刷新每天5点标志位
    if playerChange.dailyRefresh then
        EventSystem.Dispatch(EventID.New_Day_Refresh)
    end

    --仇人系统——设置 And 恩怨簿红点
    if IsServerDataNotNil(playerChange.rivalBriefInfo) then
        xpcall(MDL.Rival.SyncRivalBriefInfo, private.PlayerChangeErrorMsg, playerChange.rivalBriefInfo)
    end

    --头像
    if IsServerDataNotNil(playerChange.portraitInfos) then
        xpcall(MDL.Character.SyncPortraitsList, private.PlayerChangeErrorMsg, playerChange.portraitInfos)
    end
    
    --头像框
    if IsServerDataNotNil(playerChange.frameInfos) then
        xpcall(MDL.Character.SyncFramesList, private.PlayerChangeErrorMsg, playerChange.frameInfos)
    end
   
    --开放金品质列表
    if IsServerDataNotNil(playerChange.goldenInfo) then
        xpcall(MDL.HideGolden.SetOpenGoldenList, private.PlayerChangeErrorMsg, playerChange.goldenInfo)
    end

    --外观_光效
    if IsServerDataNotNil(playerChange.lightEffectInfos) then
        xpcall(MDL.LightEffect.SyncLightEffectInfoDic, private.PlayerChangeErrorMsg, playerChange.lightEffectInfos)
    end
    
    --光效变化信息
    if IsServerDataNotNil(playerChange.lightEffectPictorial) then
        xpcall(MDL.LightEffect.SyncLightEffectPictorialInfo, private.PlayerChangeErrorMsg, playerChange.lightEffectPictorial, false) 
    end

    --公平竞技活动积分推送
    if IsServerDataNotNil(playerChange.fairPlayInfoChange) then
        xpcall(MDL.FairPlay.PushFairPlayScore, private.PlayerChangeErrorMsg, playerChange.fairPlayInfoChange)
    end

    --region ********************* 战令 ***********************
    --战令挑战-每日挑战
    if IsServerDataNotNil(playerChange.dailyHonorTaskInfos) then
        xpcall(MDL.HonorOrder.SyncHonorOrderDailyTaskList, private.PlayerChangeErrorMsg, playerChange.dailyHonorTaskInfos)
    end
    --战令挑战-周期挑战
    if IsServerDataNotNil(playerChange.cycleHonorTaskInfos) then
        xpcall(MDL.HonorOrder.SyncHonorOrderCycleTaskList, private.PlayerChangeErrorMsg, playerChange.cycleHonorTaskInfos)
    end
    --endregion ************************** 战令 **********************

    --势力战跨服信息
    if IsServerDataNotNil(playerChange.guildWarCrossOpen) then
        xpcall(MDL.GuildWar.SyncPlayerChangeCrossOpen, private.PlayerChangeErrorMsg, playerChange.guildWarCrossOpen)
    end

    --region 押镖
    if IsServerDataNotNil(playerChange.escortBase) then
        xpcall(MDL.GuildEscort.SyncEscortBase, private.PlayerChangeErrorMsg, playerChange.escortBase)
    end
    if IsServerDataNotNil(playerChange.cart) then
        xpcall(MDL.GuildEscort.SyncEscortCart, private.PlayerChangeErrorMsg, playerChange.cart)
    end
    if IsServerDataNotNil(playerChange.escortRivals) then
        xpcall(MDL.GuildEscort.SyncEscortRivals, private.PlayerChangeErrorMsg, playerChange.escortRivals)
    end
    --endregion 押镖

    --0元购
    if IsServerDataNotNil(playerChange.freePurchaseInfo) then
        xpcall(MDL.FreeBuy.SyncActivityInfo, private.PlayerChangeErrorMsg, playerChange.freePurchaseInfo)
    end

    --服务器下发道具来源信息
    xpcall(MDL.ItemSources.SyncServerItemSourcesMapData, private.PlayerChangeErrorMsg, playerChange.itemResInfos)

    if IsProtoDataNotNil(playerChange.customRoomInfo) then
        xpcall(MDL.CustomRoom.SetRoomInfo, private.PlayerChangeErrorMsg, playerChange.customRoomInfo, false)
    end

    --1v1公平竞技奖励信息
    if IsServerDataNotNil(playerChange.fairPlaySoloRewardInfo) then
        xpcall(MDL.SyncSolo.SyncRewardInfo, private.PlayerChangeErrorMsg, playerChange.fairPlaySoloRewardInfo)
    end

    --3v3 公平竞技奖励信息
    if IsProtoDataNotNil(playerChange.battleRewardInfo) then
        xpcall(MDL.SyncTeamPVP.SyncTeamPVPRewardInfo, private.PlayerChangeErrorMsg, playerChange.battleRewardInfo)
    end

    -- 坐骑外观
    MDL.WarHorse.SyncHorseAppearanceInfo(playerChange.horseAppearance, playerChange.horseInfoList)

    -- 国战悬赏任务
    if IsServerDataNotNil(playerChange.wantedTaskInfo) then
        xpcall(MDL.CountryWantedTask.SyncWantedTaskInfo, private.PlayerChangeErrorMsg, playerChange.wantedTaskInfo)
    end

    -- 关注有礼
    if IsServerDataNotNil(playerChange.pushInterFaceInfos) then
        xpcall(MDL.Attention.SyncPushInterFaceInfo, private.PlayerChangeErrorMsg, playerChange.pushInterFaceInfos)
    end
    
    -- 天地群雄 膜拜信息
    if IsServerDataNotNil(playerChange.worshipInfo) then
        MDL.HeroMatch1v1.SyncHeroMatchWorshipInfo(playerChange.worshipInfo)
    end

    if IsProtoDataNotNil(playerChange.worshipInfo3V3) then
        MDL.HeroMatch3v3.SyncHeroMatchWorshipInfo(playerChange.worshipInfo3V3)
    end

    -- 天地群雄 弹幕信息
    if IsServerDataNotNil(playerChange.watchBattleChatInfo) then
        MDL.WatchBattle.SyncWatchBattleChatCount(playerChange.watchBattleChatInfo)
    end
    
    -- 通用布阵信息
    if IsServerDataNotNil(playerChange.commonLineUpInfo) then
        MDL.FreeLineUp.SyncCommonLineUpInfo(playerChange.commonLineUpInfo)
    end

    -- 日服下载
    if IsServerDataNotNil(playerChange.japanUpdateVersionInfo) then
        xpcall(MDL.PreDownloadJP.SyncPreHotfixState, private.PlayerChangeErrorMsg, playerChange.japanUpdateVersionInfo)
    end
    -- 国家相关信息
    if IsServerDataNotNil(playerChange.countryPlayerChange) then
        MDL.Country.SetCountryPlayerChange(playerChange.countryPlayerChange)
    end
    -- 纳灵系统
    if IsServerDataNotNil(playerChange.recycleFragmentInfo) then
        MDL.Reborn.SyncRecycleFragment(playerChange.recycleFragmentInfo)
    end

    --回放 战斗记录删除id
    xpcall(MDL.Replay.SyncFairPlayMyRecordDelId, private.PlayerChangeErrorMsg, playerChange.fairPlayMyRecordDelId)
    
    --荣誉印记
    if IsServerDataNotNil(playerChange.honorSignetInfo) then
        xpcall(MDL.HonorSignet.SetInfo, private.PlayerChangeErrorMsg, playerChange.honorSignetInfo)
    end
    -- 暴风
    if IsServerDataNotNil(playerChange.stormInfo) then
        xpcall(MDL.Storm.SyncStormInfo, private.PlayerChangeErrorMsg, playerChange.stormInfo)
    end
    -- 攻城略地（GVG）
    if IsServerDataNotNil(playerChange.GVGRedPointInfo) then
        xpcall(MDL.GVGFight.SyncRedPointData, private.PlayerChangeErrorMsg, playerChange.GVGRedPointInfo)
    end
    if IsServerDataNotNil(playerChange.gvgHighYieldAndStageInfo) then
        xpcall(MDL.GVGFight.SyncGVGHighYieldAndStageInfo, private.PlayerChangeErrorMsg, playerChange.gvgHighYieldAndStageInfo)
    end

    --天下会武1V1
    if IsServerDataNotNil(playerChange.fairTournamentTaskInfos) then
        xpcall(MDL.FairSoloTournament.SetTaskInfo, private.PlayerChangeErrorMsg, playerChange.fairTournamentTaskInfos)
    end
    
    -- 周历是否报名
    if IsServerDataNotNil(playerChange.signUpInfo) then
        xpcall(MDL.Activities.SyncActivationCalenderSignUp, private.PlayerChangeErrorMsg, playerChange.signUpInfo)
    end

    if IsServerDataNotNil(playerChange.questionnairAwards) then
        xpcall(MDL.Questionnaire.SetQuestionnaireReward, private.PlayerChangeErrorMsg, playerChange.questionnairAwards, true)
    end

    -- 势力挖矿
    if IsProtoDataNotNil(playerChange.guildMineInfo) then
        xpcall(MDL.GuildMine.SyncGuildMineInfo, private.PlayerChangeErrorMsg, playerChange.guildMineInfo, true)
    end

    -- 神兽养成信息
    if IsProtoDataNotNil(playerChange.godBeastDevelopInfo) then
        xpcall(MDL.GodBeast.PlayerChangeUpdateDevelopInfo, private.PlayerChangeErrorMsg, playerChange.godBeastDevelopInfo)
    end
    

    if IsProtoDataNotNil(playerChange.syncFourCountryInfo) then
        xpcall(MDL.SyncFourCountryWar.InitTime, private.PlayerChangeErrorMsg, playerChange.syncFourCountryInfo)
    end

    -- 宠物信息
    if IsProtoDataNotNil(playerChange.petGlobalInfo) then
        xpcall(MDL.Pet.SetGlobalInfo, private.PlayerChangeErrorMsg, playerChange.petGlobalInfo, false)
    end
    if IsProtoDataNotNil(playerChange.petList) then
        xpcall(MDL.Pet.SetPetInfoList, private.PlayerChangeErrorMsg, playerChange.petList, false)
    end
    if IsProtoDataNotNil(playerChange.petSlotList) then
        xpcall(MDL.Pet.SetSlotInfo, private.PlayerChangeErrorMsg, playerChange.petSlotList, false)
    end
    if IsProtoDataNotNil(playerChange.petFormationInfo) then
        xpcall(MDL.Pet.SetFormationInfo, private.PlayerChangeErrorMsg, playerChange.petFormationInfo, false)
    end

    if IsProtoDataNotNil(playerChange.threeTeamsPKInfo) then
        xpcall(MDL.ThreeTeamFight.SyncBasicInfo, private.PlayerChangeErrorMsg, playerChange.threeTeamsPKInfo)
    end

    if IsProtoDataNotNil(playerChange.siegeCityBaseInfo) then
        xpcall(MDL.ChangAnSiege.InitSiegeCityBaseInfo, private.PlayerChangeErrorMsg, playerChange.siegeCityBaseInfo)
    end

    if IsProtoDataNotNil(playerChange.expelMonsterInfo) then
        xpcall(MDL.ExpelMonster.SyncBasicInfo, private.PlayerChangeErrorMsg, playerChange.expelMonsterInfo)
    end
    
    -- 王者挑战
    if IsProtoDataNotNil(playerChange.kingChallengeInfo) then
        xpcall(MDL.KingChallenge.SyncSeasonInfo, private.PlayerChangeErrorMsg, playerChange.kingChallengeInfo)
    end

    -- 1v1、3v3公平竞技道具卡使用信息
    if IsProtoDataNotNil(playerChange.fairPlayCard) then
        xpcall(MDL.FairPlayCard.SyncInfo, private.PlayerChangeErrorMsg, playerChange.fairPlayCard)
    end
    
    -- 会长激励
    if IsProtoDataNotNil(playerChange.guildLeaderTaskInfo) then
        xpcall(MDL.Guild.SetLeaderTaskInfo, private.PlayerChangeErrorMsg, playerChange.guildLeaderTaskInfo, false)
    end

    if IsProtoDataNotNil(playerChange.CNBCountryLimit) then
        xpcall(MDL.CountryNightBoss.SetLineUpCountryLimits, private.PlayerChangeErrorMsg, playerChange.CNBCountryLimit, false)
    end
    --势力GVE
    if IsProtoDataNotNil(playerChange.gveSeasonInfo) then
        xpcall(MDL.SlgGvE.UpdateSeasonInfo, private.PlayerChangeErrorMsg, playerChange.gveSeasonInfo)
    end
    if IsProtoDataNotNil(playerChange.guildGVEInfo) then
        xpcall(MDL.SlgGvE.UpdateSlgGvEInfo, private.PlayerChangeErrorMsg, playerChange.guildGVEInfo)
    end
    if IsProtoDataNotNil(playerChange.personalLandInfo) then
        xpcall(MDL.SlgGvE.SetMyOccupyGridInfo, private.PlayerChangeErrorMsg, playerChange.personalLandInfo, false)
    end
    if IsProtoDataNotNil(playerChange.gveClientShowLandInfo) then
        xpcall(MDL.SlgGvE.UpdateAttackingCityOrBossInfo, private.PlayerChangeErrorMsg, playerChange.gveClientShowLandInfo)
    end

    if IsProtoDataNotNil(playerChange.recallGiftInfo) then
        xpcall(MDL.AppPushGift.UpdateRecallGiftInfo, private.PlayerChangeErrorMsg, playerChange.recallGiftInfo)
    end

    if IsProtoDataNotNil(playerChange.weaponSoulInfo) then
        xpcall(MDL.DivineWeaponForgeSoul.UpdateWeaponForgeSoulInfo, private.PlayerChangeErrorMsg, playerChange.weaponSoulInfo)
    end

    if IsProtoDataNotNil(playerChange.personalAuctionBonus) then
        xpcall(MDL.Guild.UpdateWeekAuctionBonus, private.PlayerChangeErrorMsg, playerChange.personalAuctionBonus)
    end

    if IsProtoDataNotNil(playerChange.LaterEnterInfo) then
        xpcall(MDL.LaterEnter.SyncInfo, private.PlayerChangeErrorMsg, playerChange.LaterEnterInfo)
    end

    
    if IsProtoDataNotNil(playerChange.openAwakenChallengeHeroList) then
        xpcall(MDL.AwakenActivity.UpdateAwakenActivityInfo, private.PlayerChangeErrorMsg, playerChange.openAwakenChallengeHeroList)
    end
    if IsProtoDataNotNil(playerChange.heroAwakenInfos) then
        xpcall(MDL.HeroAwaken.SetAwakenInfo, private.PlayerChangeErrorMsg, playerChange.heroAwakenInfos, false)
    end
    if IsProtoDataNotNil(playerChange.awakenTaskInfos) then
        xpcall(MDL.HeroAwaken.SetTaskInfo, private.PlayerChangeErrorMsg, playerChange.awakenTaskInfos, false)
    end

    if IsProtoDataNotNil(playerChange.decorateInfo) then
        xpcall(MDL.Decoration.UpdateInfo, private.PlayerChangeErrorMsg, playerChange.decorateInfo)
    end
        
    if IsProtoDataNotNil(playerChange.dyeAppearanceInfo) then
        xpcall(MDL.DyeAppearance.SetDyeAppearanceInfos, private.PlayerChangeErrorMsg, playerChange.dyeAppearanceInfo, false)
    end

    --更新解锁条件
    MDL.Unlock.Update()

    EventSystem.Dispatch(EventID.UI_UpdatePlayerChange)
end

function private.PlayerChangeErrorMsg(msg)
    if not PersistentData.PlayerData then --如果还没有这个模块说明enterWorld还没有到
        logging.error(LTAG.ERROR, "PlayerChange比EnterWorld先发过来，PersistentData模块还没有初始化！", msg)
    else
        logging.error(LTAG.ERROR, "PlayerChange执行失败", msg)
    end
end

function private.UpdateRewardInfo(rewards, rewardShowId,isServerLevelEffected)
    if not rewards then
        return
    end
    MDL.Reward.GainRewards(rewards, rewardShowId,isServerLevelEffected)
end

-- 获取战力，通过判断，执行战力增加界面
function Player_Model.UpdateLineUpGs(lineUpGs, isInit)
    if lineUpGs then
        local changeGs = lineUpGs
        if changeGs > private._currentLineUpGs and private._currentLineUpGs ~= 0 then
            Player_Model.ShowGSChangeExp(lineUpGs, private._currentLineUpGs)
        end
        private._currentLineUpGs = changeGs
        if not isInit then
            EventSystem.Dispatch(EventID.UI_UpdateClimbTowerInfo)
            EventSystem.Dispatch(EventID.CharacterTeamGsChange)
            EventSystem.Dispatch(EventID.UI_Activity_Refresh_Single_RedPoint, LuaConst.ActivityType.MainlLine, CTL.LevelSelect.IsShowLevelSelectRedPoint())
        end
    end
end

--有些系统需要延迟播放表现，这里加个标识判断
function Player_Model.SetDelayGSExpFlag(value)
    private.isDelayGSExp = value
end

function Player_Model.DelayShowGSExp()
    if #private.gsContext > 0 then
        private.gsContext.timeSinceUpdate = nil
        UIManager.OpenView(Const_UI_Lua.UIEnum.UICharacterTeamLevelUp, private.gsContext)
    end
end

--提高战力变化表现
function Player_Model.ShowGSChangeExp(newGS, oldGS)
    if newGS <= oldGS then
        return
    end
    private.gsContext[1] = newGS
    private.gsContext[2] = oldGS
    private.gsContext.timeSinceUpdate = nil
    if BattleDataGetter.IsOnlineTownLevel() then
        if private.isDelayGSExp then
            return
        end
        if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UICharacterTeamLevelUp) then
            UIManager.CloseView(Const_UI_Lua.UIEnum.UICharacterTeamLevelUp)
        end
        UIManager.OpenView(Const_UI_Lua.UIEnum.UICharacterTeamLevelUp, private.gsContext)
    else
        CTL.HomeMain.AddTownHomeDelayFuncNoUI(private.OpenUICharacterTeamLevelUp, private.gsContext)
    end
end


function Player_Model.GetLineUpGs()
    return private._currentLineUpGs
end

function private.OpenUICharacterTeamLevelUp(gsContext)
    UIManager.OpenView(Const_UI_Lua.UIEnum.UICharacterTeamLevelUp, gsContext)
end

--endregion 数据操作

--region -- **************** 协议部分 ******************* --

function private.G2CPushPlayerChangeRegister()
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushPlayerChange,private.G2CPushPlayerChangeResponse)
end

function private.G2CPushPlayerChangeResponse(msgResp)
    private.UpdatePlayerChange(msgResp.PlayerChange, MessageEnums.MessageG2CPushPlayerChange)
    private.UpdateRewardInfo(msgResp.Rewards, msgResp.RewardShowId,msgResp.isServerLevelEffected)
end

function Player_Model.CommonProcessResponse(msgResp, msgId)
    private.UpdatePlayerChange(msgResp.Resp.PlayerChange, msgId)
    private.UpdateRewardInfo(msgResp.Resp.Rewards, msgResp.Resp.RewardShowId,msgResp.Resp.isServerLevelEffected)
end

function Player_Model.OnDailyRefreshResponse(playerChange)
    private.UpdatePlayerChange(playerChange, MessageEnums.MessageG2CDailyRefresh)
end



--endregion 协议部分

local teamLevel
local teamLevelExp
local teamRankID
local roleId = 0
local lineUpHeroIds = {}
local lineUpHeroPower = {}
local curShowId = nil
local teamAttr = {}
local teamGs
local serverDay = nil
local serverLevel = nil
local serverOpenTs = nil
local threeTeamGs = nil

local lineUpHeroInfoDict = {}

function Player_Model.GetRoleInfo()
    return teamLevel,teamLevelExp,teamRankID
end

function Player_Model.GetRoleLevel(  )
    return teamLevel
end

function Player_Model.GetRoleLevelExp(  )
    return teamLevelExp
end

function Player_Model.GetRoleRankID(  )
    return teamRankID
end

function Player_Model.GetRoleId( )
    return roleId
end

function Player_Model.GetTeamAttr()
    return teamAttr
end

function Player_Model.GetTeamGs()
    return teamGs
end

function Player_Model.GetLinUpHeroId()
    if lineUpHeroIds[3] > 0 then
        return lineUpHeroIds[3]
    end
    for i,v in ipairs(lineUpHeroIds) do
        if v>0 then
            return v
        end
    end
    return  MDL.HeroSelect.GetHasHeroList()[1].heroId
end

function Player_Model.SetRoleInfo(teamlevel,teamlevelexp,teamrankid,teamattr,teamgs)
    teamLevel = teamlevel
    teamLevelExp = teamlevelexp
    teamRankID = teamrankid
    --处理proto属性第一个空值
    UTL.Attr.ProcessProtoAttrTable(teamattr.attrs)
    teamAttr = teamattr
    teamGs = teamgs or teamGs
end

function Player_Model.SetHeroLineUpInfo(ids,gs,Tgs)
    if ids ~= nil and #ids>0 then
        local isChange = CTL.AssistanceFight.CalculateFormationBuffChanges(lineUpHeroIds, ids)
        lineUpHeroIds = ids
        Player_Model.UpdateHeroInfDict(ids)
        if isChange then
            EventSystem.Dispatch(EventID.UI_AssistanceFight_TeamworkBuffChange)
        end
    end
    if gs~=nil and #gs>0 then
        lineUpHeroPower = gs
    end
    threeTeamGs = Tgs
end

function Player_Model.UpdateHeroInfDict(ids)
    table.clear(lineUpHeroInfoDict)
    local heroInfoList = MDL.HeroSelect.GetHasHeroList()
    for i, v in ipairs(ids) do
        for _, heroInfo in ipairs(heroInfoList) do
            if heroInfo.heroId == v then
                lineUpHeroInfoDict[v] = heroInfo
            end
        end
    end
end

function Player_Model.GetLineUpHeroInfoByHeroId(heroId)
    return lineUpHeroInfoDict[heroId]
end

function private.IpairsValue(maxCount, curIndex)
    if maxCount > curIndex then
        curIndex = curIndex + 1
        local heroId = lineUpHeroIds[curIndex] 
        if heroId and heroId > 0 then
            return curIndex, lineUpHeroInfoDict[heroId]
        else
            return nil
        end
    end
end

function Player_Model.GetLineUpHeroInfoEnumerator()
    return private.IpairsValue, 6, 0
end

-- 阵容数组
function Player_Model.GetHeroLinUpIds()
    return lineUpHeroIds
end

function Player_Model.GetHeroLinUpPower()
    return lineUpHeroPower
end

function Player_Model.HeroIsLineUp(id)
    for i,v in ipairs(lineUpHeroIds) do
        if v == id then
            return true
        end
    end
    return false
end

function Player_Model.GetLineUpHeroCount()
    local count = 0
    for i, v in ipairs(lineUpHeroIds) do
        if v > 0 then
            count = count + 1
        end
    end
    return count
end

function Player_Model.SetRoleId(id)
    roleId = id
    SDKUtil.SetRoleId(tostring(id))
    PersistentData.PlayerData:Set("roleId", roleId, true)
    PersistentData.DeviceData:Set("lastLoginRoleId", roleId, true)
end

function Player_Model.GetCurShowId()
    if not curShowId then
        curShowId = BattleDataGetter.GetMyOriginArmyHeroID()
    end
    return curShowId
end

function Player_Model.SetCurShowId(id)
    curShowId = id
end

function Player_Model.SetServerDay(sd)
    logging.log(LTAG.LOG,"  SetServerDay ",sd.serverDayCount)
    serverDay = sd
    serverLevel = sd.serverLevel
    EventSystem.Dispatch(EventID.UI_UpdateServerDay)
end

function Player_Model.SetServerOpenTs(ts)
    logging.log(LTAG.LOG,"  SetServerOpenTs ",ts)
    serverOpenTs = ts
end

function Player_Model.HaveServerDay()
    if serverDay then
        return true
    end
    return false
end

function Player_Model.GetServerLevel()
    return serverLevel
end

function Player_Model.GetLastServerLevel()
    local serverDayCount = Player_Model.GetServerDayCount()-1
    if serverDayCount<=0 then
        return 0
    end
    local maxDayCount = DataSheetManager.ServerLevel:GetDataCount()
    if serverDayCount>maxDayCount then
        serverDayCount = maxDayCount
    end
    local serverData = DataSheetManager.ServerLevel:GetDataByServerDayCount(serverDayCount)
    return serverData.ServerLevel
end

-- 战区开启后为了追平世界等级，从大取最大开服天数
function Player_Model.GetServerDayCount()
    if CTL.WarZone.IsWarZoneOpen() then
        return UTL.Time.GetGameDiffDayCount(UTL.Time.GetServerTimestamp(), MDL.WarZone.GetWarZoneLongestOpenTime())
    else
        return Player_Model.GetPersonalServerDayCount()
    end
end

--当前距离开服天数的时间戳
function Player_Model.GetServerDayCountTimestamp()
    if CTL.WarZone.IsWarZoneOpen() then
        return MDL.WarZone.GetWarZoneLongestOpenTime()
    else
        return Player_Model.GetServerOpenTs()
    end
end

-- 获取当前服务器开服时间，每次 EnterWorld 刷到这个值
function Player_Model.GetServerOpenTs()
    return serverOpenTs
end

-- 单服开启天数
function Player_Model.GetPersonalServerDayCount()
    if serverDay then
        return serverDay.serverDayCount
    end
    logging.error(LTAG.ERROR,"serverDay nil")
    return 0
end

function Player_Model.GetDayCountByLevel(level)
    local dayCount = 0
    for i, v in DataSheetManager.ServerLevel:GetEnumerator() do
        if level < v.ServerLevel then
            break
        end
        dayCount = v.ServerDayCount
    end
    return dayCount
end

function private.GetLinUpHeroId()
    if lineUpHeroIds[3] > 0 then
        return lineUpHeroIds[3]
    end
    for i,v in ipairs(lineUpHeroIds) do
        if v>0 then
            return v
        end
    end
    return MDL.HeroSelect.GetHasHeroList()[1].heroId
end

function Player_Model.Set_TypeState(type, state)
    private.wearViewToggleStateTypeDic[type] = state
    local tb = PersistentData.PlayerData:Get(WEAR_STATE_KEY)
    if tb == nil then
        tb = {}
    end
    tb[type] = state and 1 or -1
    PersistentData.PlayerData:Set(WEAR_STATE_KEY, tb, true)
end

--默认第一次返回false，不勾选
function Player_Model.Get_TypeState(type)
    if private.wearViewToggleStateTypeDic[type] ~= nil then
       return private.wearViewToggleStateTypeDic[type]
    end
    local tb = PersistentData.PlayerData:Get(WEAR_STATE_KEY)
    local value = 0
    if tb ~= nil then
        value = tb[type]
        if value == nil then
            value = 0
        end
    end
    if value == 0 then
        return false
    else
        return value == 1 and true or false
    end
end

function Player_Model.GetFormationGS(formationIndex)
    if not threeTeamGs or not threeTeamGs[formationIndex] then
        return 0
    end

    return threeTeamGs[formationIndex]
end

function Player_Model.HeroIsMainLineUp(id)
    for i = 1, 6, 2 do
        local heroLinUpId = lineUpHeroIds[i]
        if heroLinUpId == id then
            return true
        end
    end
    return false
end

-- 舆情控制开关，后面改为GMS开关，这次先写死
function Player_Model.GetPublicSentimentUnLock()
    return true
end

--通用的获取他人外显数据的请求
function Player_Model.CommonGetOtherPeopleInfoReq(acids, funcId)
    private.funcIdGetOtherPeople = funcId
    local msg = other_info_pb.OtherPeopleInfoReq()
    for i, v in ipairs(acids) do
        table.insert(msg.otherAcids, v)
    end
    NetManager.SendMessage(MessageEnums.MessageOtherPeopleInfo, msg)
end

function private.OnOtherPeopleResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.GetOtherPeopleInfo, private.funcIdGetOtherPeople, msgResp.infos)
    end
end

function Player_Model.SetCreatePlayerTime(time)
    private.createPlayerTime = time
end

function Player_Model.GetCreatePlayerTime()
    return private.createPlayerTime
end

return Player_Model