local SlgGvE_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')
local gve_base = require('Proto/gve_base_pb')
local GvEConstData = DataSheetManager.SlgGvEConstData:GetDataByID(1)

SlgGvE_Model.GRID_SIZE = 160

SlgGvE_Model.OfficialTaskState = {
    Finished = gve_base.Finished,       -- 已完成
    UnFinished = gve_base.UnFinished,   -- 未完成
    Received = gve_base.Received        -- 已领取
}

SlgGvE_Model.SeasonState = {
    End = 0,           -- 休赛期
    Playing = 1,       -- 赛季进行中
    Showing = 2,       -- 展示期
}

--地块类型枚举
SlgGvE_Model.GridType = {
    Block = 0, --阻挡
    Normal_1 = 1,
    Normal_2 = 2,
    Normal_3 = 3,
    Elite = 4, --精英
    Boss = 5, --Boss
}

function SlgGvE_Model.OnStartup()
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEOfficialLevelUp, nil)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEOfficialTaskReward, nil)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVETalentLevelUp, private.GVETalentLevelUpResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVETrade, private.GVETradeResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEMainPanel, private.GVEMainPanelResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEGiveUpLand, private.GVEGiveUpLandResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CGVELandInfoChange, private.G2CGVELandInfoChange)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEGetLandDetail, private.GVEGetLandDetailResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEPersonalLandSweep, private.GVEPersonalLandSweepResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVELandMark, nil)
    NetManager.RegisterMsgCB(MessageEnums.MessageGVEGetLastSeasonBeatRecord, private.GVEGetLastSeasonBeatRecordResp)


    EventSystem.Regist(EventID.AcquireSystemRedAfterUnlock, private.OnEnterWorldPostprocess)
    EventSystem.Regist(EventID.OnReConnectOk, private.ProcessLogoutCase)

    private.blockGridSet = nil --阻挡地块集合
    private.myOccupyGridInfo = {} --我占领地块列表
    private.gridInfoDict = {} --key:index value:serverInfo
    private.curBossGveMapID = nil

    private.officialLv = 1              --当前官爵等级
    private.rewardMaxLevel = 0          --领取官爵奖励最大等级
    private.officialTaskInfoMap = {}
    --[[private.officialTaskInfoMap[officialLv][taskid] = {
        curProgresss,   --任务当前进度
        taskState,      --状态  0:已完成 1:未完成 2:已领取
        taskCfg,        --配置
    }]]--
    private.officialTaskInfoList = {}   --[officialLv, tasklist{taskId, taskLv(所属官职等级)}]
    private.talentInfoMap = {}          --[officialLv, talentList{talentId, talentCfg}]
    private.talentEnergyLimit = 0       --天赋增加的体力上限
    private.talentPlotLimit = 0         --天赋增加的占领地块数量上限
    private.isCanBorrowRoad = false     --是否可以借路
    private.materialInfoMap = {}        --[itemId, {num, gainSpeed}]
    private.teamInfoMap = {}            --[teamId, {teamEnergy, injuryEndTime}]
    private.attackingCityOrBossInfo = {}   --[landId, deadLine] --当前正在攻打的城池或者boss信息，用于城镇气泡显示
end

function private.OnEnterWorldPostprocess()
    private.ProcessMyOccupyGridInfo()
    EventSystem.Dispatch(EventID.UI_SlgGvE_SeasonTime_Update)
    EventSystem.Dispatch(EventID.UI_SlgGvE_Official_Update_Info)
    EventSystem.Dispatch(EventID.UI_SlgGvE_Talent_Update_Info)
    EventSystem.Dispatch(EventID.UI_SlgGvE_Material_Update_Info)
    EventSystem.Dispatch(EventID.UI_SlgGvE_Team_Update_Info)
    if private.attackingCityOrBossInfo.landId and private.attackingCityOrBossInfo.landId > 0 then
        CTL.SlgGvE.RefreshInfoReminder()
    end
end

--断线重连，清除缓存，关闭主界面
function private.ProcessLogoutCase()
    UIManager.CloseView(Const_UI_Lua.UIEnum.UISlgGvEMain)
    table.clear(private.gridInfoDict)
    private.curBossGveMapID = nil
    CTL.SlgGvE.CloseAllPopUpUI()
end

function SlgGvE_Model.ClearAllGrid()
    private.curBossGveMapID = nil
    table.clear(private.gridInfoDict)
    table.clear(private.myOccupyGridInfo)
end

--常量
function SlgGvE_Model.GetGvEConstData()
    return GvEConstData
end

--体力上限
function SlgGvE_Model.GetEnergyLimit()
    return private.talentEnergyLimit + GvEConstData.InitialStrengthMax
end

--占领地块数量上限
function SlgGvE_Model.GetPlotLimit()
    return private.talentPlotLimit + GvEConstData.GveInitialAcreNum
end

--是否可以借路
function SlgGvE_Model.IsCanBorrowRoad()
    return private.isCanBorrowRoad
end

--region 赛季
function SlgGvE_Model.GetSeasonPrivilegeLeftTime()
    return private.privilegeEndTime - UTL.Time.GetServerTimestamp()
end

function SlgGvE_Model.GetSeasonStartTime()
    return private.seasonStartTime 
end

function SlgGvE_Model.GetSeasonShowTime()
    return private.seasonShowTime 
end

function SlgGvE_Model.GetSeasonState()
    return private.seasonState 
end

function SlgGvE_Model.GetSeasonStateStr()
    if private.seasonState ==SlgGvE_Model.SeasonState.End then
        return UIUtils.GetLocalizedTxt(Const_IDS.IDS_SlgGve_Season_Hint_5) 
    elseif private.seasonState ==SlgGvE_Model.SeasonState.Playing then
        return UIUtils.GetLocalizedTxt(Const_IDS.IDS_SlgGve_Season_Hint_6) 
    else
        return UIUtils.GetLocalizedTxt(Const_IDS.IDS_SlgGve_Season_Hint_9) 
    end
end
--endregion 赛季

--region 排行榜
function SlgGvE_Model.GetRankSerTyp()
    return private.rankSerTyp
end

function SlgGvE_Model.IsRankOpen()
    return UTL.Time.GetServerTimestamp() - private.rankFuncOpenTime >= 0
end
--endregion 排行榜

--region 官爵（王印）
function SlgGvE_Model.GetCurOfficalLv()
    return private.officialLv
end

function SlgGvE_Model.GetOfficalTasksDataMap(officialLv)
    return private.officialTaskInfoMap[officialLv]
end

function SlgGvE_Model.GetOfficalTasksDataList(officialLv)
    return private.officialTaskInfoList[officialLv]
end

function SlgGvE_Model.GetOfficalTaskData(officialLv, taskId)
    return private.officialTaskInfoMap[officialLv][taskId]
end

function SlgGvE_Model.IsCurOfficalLvRewardReceived(officialLv)
    return private.rewardMaxLevel >= officialLv 
end

local function SortTaskInfoList(taskA, taskB)
    local taskAState = private.officialTaskInfoMap[taskA.taskLv][taskA.taskId].taskState
    local taskBState = private.officialTaskInfoMap[taskB.taskLv][taskB.taskId].taskState
    if taskAState == taskBState then
        return taskA.taskId < taskB.taskId
    else
        return taskAState < taskBState
    end
end

--endregion 官爵（王印）

--region 天赋（权柄）
function SlgGvE_Model.GetTalentAllInfoMap()
    return private.talentInfoMap
end

function SlgGvE_Model.GetTalentInfoList(officialLv)
    return private.talentInfoMap[officialLv]
end

function SlgGvE_Model.IsTalentUnlock(talentId)
    local talentCfg = DataSheetManager.SlgGvETalentData:GetDataByGveTalentID(talentId)
    for lv, infoList in pairs(private.talentInfoMap) do
        if lv <= private.officialLv then
            for index, talentInfo in ipairs(infoList) do
                if talentInfo.talentCfg.GveTalentGroupID == talentCfg.GveTalentGroupID then
                    if talentCfg.GveTalentLevel <= talentInfo.talentCfg.GveTalentLevel then
                        return true
                    end
                end
            end
        end
    end
    return false
end

local function SortTalentInfoList(talentA, talentB)
    return talentA.talentCfg.GveTalentGroupID < talentB.talentCfg.GveTalentGroupID
end
--endregion 天赋（权柄）

--region 材料
function SlgGvE_Model.GetMaterialNum(itemId)
    return private.materialInfoMap[itemId] and private.materialInfoMap[itemId].num or 0
end

function SlgGvE_Model.GetMaterialGainSpeed(itemId)
    return private.materialInfoMap[itemId] and private.materialInfoMap[itemId].gainSpeed*60 or 0
end
--endregion 材料

--region 队伍
function SlgGvE_Model.GetTeamInfoMap()
    return private.teamInfoMap
end

function SlgGvE_Model.GetTeamEnergy(teamId)
    return private.teamInfoMap[teamId] and private.teamInfoMap[teamId].teamEnergy or 0
end

function SlgGvE_Model.GetTeamInjuryLeftTime(teamId)
    local time = private.teamInfoMap[teamId] and private.teamInfoMap[teamId].injuryEndTime or 0 
    return time - UTL.Time.GetServerTimestamp()
end
--endregion 队伍

--region 地块
function private.SortByEnableAttack(index_a, index_b)
    local isLink_a, isMyLink_a = CTL.SlgGvE.CheckGridIfLinked(index_a)
    local isLink_b, isMyLink_b = CTL.SlgGvE.CheckGridIfLinked(index_b)
    if isLink_a == isLink_b then
        if isMyLink_a == isMyLink_b then
            return index_a < index_b
        else
            return isMyLink_a
        end
    else
        return isLink_a
    end
end

function SlgGvE_Model.CollectTargetGrid(gridType, level, list)
    table.clearArray(list)
    for index, v in pairs(private.gridInfoDict) do
        local type, info = SlgGvE_Model.GetGridInfo(index)
        if type == gridType and info.hasOccupy == false then
            local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(info.gveMapID)
            if gridCfg.GveMapLevel == level then
                table.insert(list, index)
            end
        end
    end
    --可攻打排在前
    table.sort(list, private.SortByEnableAttack)
end

function SlgGvE_Model.IsOtherPlayerAttacking(index)
    local type, info = SlgGvE_Model.GetGridInfo(index)
    if type == SlgGvE_Model.GridType.Normal_1 or type == SlgGvE_Model.GridType.Normal_2 or type == SlgGvE_Model.GridType.Normal_3 then
        return info.attackState
    end
    return false
end

function SlgGvE_Model.TryGetLinkedGridSet(gridIndex)
    local type, info = SlgGvE_Model.GetGridInfo(gridIndex)
    if type == SlgGvE_Model.GridType.Elite or type == SlgGvE_Model.GridType.Boss then
        local result = {}
        local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(info.gveMapID)
        local posCfg = DataSheetManager.SlgGvEPlotPosition:GetDataByGveMapPositionID(gridCfg.GveMapPositionID)
        for i, index in ipairs(posCfg.GveMapPlotPosition) do
            result[index] = true
        end
        result[gridIndex] = true
        return result
    end
    return nil
end

function private.CollectLinkedGridInfo(serverData, result)
    --中心地块储存数据，相邻地块储存中心地块索引
    local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(serverData.gveMapID)
    local posCfg = DataSheetManager.SlgGvEPlotPosition:GetDataByGveMapPositionID(gridCfg.GveMapPositionID)
    local middleIndex
    for i, index in ipairs(posCfg.GveMapPlotPosition) do
        if i == 1 then
            middleIndex = index
            result[index] = serverData
        else
            result[index] = middleIndex
        end
    end
end

function SlgGvE_Model.CollectEliteBossGrids(result)
    table.clearArray(result)
    for i, v in DataSheetManager.SlgGvEPlotPosition:GetEnumerator() do
        table.insert(result, private.gridInfoDict[v.GveMapPlotPosition[1]])
    end
    table.sort(result, private.SortByOccupiedState)
end

function SlgGvE_Model.GetEliteBossGridCount()
    local maxCount = DataSheetManager.SlgGvEPlotPosition:GetDataCount()
    local occupiedCount = 0
    for i, v in DataSheetManager.SlgGvEPlotPosition:GetEnumerator() do
        if private.gridInfoDict[v.GveMapPlotPosition[1]] and private.gridInfoDict[v.GveMapPlotPosition[1]].hasOccupy then
            occupiedCount = occupiedCount + 1
        end
    end
    return occupiedCount, maxCount
end

function private.SortByOccupiedState(info_a, info_b)
    local isAttack_a = info_a.resetDeadLine > 0
    local isAttack_b = info_b.resetDeadLine > 0
    if isAttack_a == isAttack_b then
        if info_a.hasOccupy == info_b.hasOccupy then
            if info_a.hasEnemy == info_b.hasEnemy then
                return info_a.gveMapID < info_b.gveMapID
            else
                if info_a.hasEnemy == true then
                    return true
                elseif info_b.hasEnemy == true then
                    return false
                end
            end
        else
            return info_b.hasOccupy
        end
    else
        return isAttack_a
    end
end

function private.UpdateGridInfo(normalInfos, eliteInfos, bossInfo)
    for _, v in ipairs(normalInfos) do
        private.gridInfoDict[v.pointIndex] = v
    end
    for _, info in ipairs(eliteInfos) do
        private.CollectLinkedGridInfo(info, private.gridInfoDict)
        CTL.SlgGvE.ProcessMarkContent(info)
    end
    if IsProtoDataNotNil(bossInfo) then
        --boss只有一只，但是id不唯一，需要将原来的boss移除
        if private.curBossGveMapID and bossInfo.gveMapID ~= private.curBossGveMapID then
            private.RemoveBossGridInfo()
        end
        private.CollectLinkedGridInfo(bossInfo, private.gridInfoDict)
        private.curBossGveMapID = bossInfo.gveMapID
        CTL.SlgGvE.ProcessMarkContent(bossInfo)
    end
    EventSystem.Dispatch(EventID.UI_SlgGve_UpdateGridInfo)
end

function private.RemoveBossGridInfo()
    local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(private.curBossGveMapID)
    local posCfg = DataSheetManager.SlgGvEPlotPosition:GetDataByGveMapPositionID(gridCfg.GveMapPositionID)
    for i, index in ipairs(posCfg.GveMapPlotPosition) do
        private.gridInfoDict[index] = nil
    end
end

function SlgGvE_Model.CheckBossOccupied()
    if private.curBossGveMapID then
        local index = SlgGvE_Model.GetEliteBossGridIndex(private.curBossGveMapID)
        local _, info = SlgGvE_Model.GetGridInfo(index)
        return info.hasOccupy == true
    end
    return false
end

function SlgGvE_Model.GetCurBossGveMapID()
    return private.curBossGveMapID
end

--初始化阻碍地块
function SlgGvE_Model.CheckIsBlockGrid(index)
    if private.blockGridSet == nil then
        private.blockGridSet = {}
        CTL.SlgGvE.CollectAllBlock(private.blockGridSet)
    end
    return private.blockGridSet[index]
end

function SlgGvE_Model.GetEliteBossGridIndex(gveMapID)
    local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(gveMapID)
    local posCfg = DataSheetManager.SlgGvEPlotPosition:GetDataByGveMapPositionID(gridCfg.GveMapPositionID)
    return posCfg.GveMapPlotPosition[1]
end

function SlgGvE_Model.GetGridCfg(index)
    local value = private.gridInfoDict[index]
    if value then
        local gridInfo
        if type(value) == 'number' then
            --这个值是多地块的中心位置索引
            gridInfo = private.gridInfoDict[value]
        else
            gridInfo = value
        end
        local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(gridInfo.gveMapID)
        return gridCfg
    end
    return nil
end

function SlgGvE_Model.GetGridInfo(index)
    local block = SlgGvE_Model.CheckIsBlockGrid(index)
    if block then
        return SlgGvE_Model.GridType.Block, block, 0
    end
    local gridInfo, middleIndex
    local value = private.gridInfoDict[index]
    if value then
        if type(value) == 'number' then
            middleIndex = value
            --这个值是多地块的中心位置索引
            gridInfo = private.gridInfoDict[value]
        else
            middleIndex = 0
            gridInfo = value
        end
        local gridCfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(gridInfo.gveMapID)
        return gridCfg.GveMapType, gridInfo, middleIndex
    end
    return SlgGvE_Model.GridType.Block, nil, 0
end

--我自己的占领信息
function SlgGvE_Model.SetMyOccupyGridInfo(info, isInit)
    for i, v in ipairs(info) do
        private.myOccupyGridInfo[v.pointIndex] = v
    end
    if isInit == false then
        private.ProcessMyOccupyGridInfo()
    end
end

function SlgGvE_Model.CheckGridMyOccupied(index)
    return private.myOccupyGridInfo[index] ~= nil
end

function private.RemoveMyOccupyGrid(index)
    private.myOccupyGridInfo[index] = nil
    private.ProcessMyOccupyGridInfo()
end

function private.ProcessMyOccupyGridInfo()
    CTL.SlgGvE.CheckMyOccupyGridRed()
    EventSystem.Dispatch(EventID.UI_SlgGve_UpdateMyOccupyGridInfo)
end

function SlgGvE_Model.PairsMyOccupyGridInfo()
    return pairs(private.myOccupyGridInfo)
end

function SlgGvE_Model.GetMyOccupyGridCount()
    return table.getDictCount(private.myOccupyGridInfo)
end

function SlgGvE_Model.GetMyOccupyGridMaxLevel()
    local maxLevel = 1
    for index, info in pairs(private.myOccupyGridInfo) do
        local cfg = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(info.gveMapID)
        if maxLevel < cfg.GveMapLevel then
            maxLevel = cfg.GveMapLevel
        end
    end
    return maxLevel
end

function SlgGvE_Model.GetThiefGridInfo()
    for index, v in pairs(private.myOccupyGridInfo) do
        if v.hasThief then
            return index, v.thiefEndTime
        end
    end
    return nil
end

function SlgGvE_Model.CheckGridIndexHasThief(index)
    local info = private.myOccupyGridInfo[index]
    if info then
        return info.hasThief, info.thiefEndTime
    end
    return false
end

function SlgGvE_Model.GetAttackingCityOrBossInfo()
    return private.attackingCityOrBossInfo
end

function SlgGvE_Model.GetSortedOccupiedGrids()
    local list = {}
    for i, v in pairs(private.myOccupyGridInfo) do
        table.insert(list, v)
    end
    table.sort(list, private.SortOccupiedGrids)
    return list
end

--1.领地级别由高到低
--2.同级别按木材、铁矿、粮草的顺序
--3.同类型按占领时间由先到后
function private.SortOccupiedGrids(a, b)
    local cfg_1 = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(a.gveMapID)
    local cfg_2 = DataSheetManager.SlgGvEPlotData:GetDataByGveMapID(b.gveMapID)
    if cfg_1.GveMapLevel == cfg_2.GveMapLevel then
        if cfg_1.GveMapType == cfg_2.GveMapType then
            return a.occupyTime < b.occupyTime
        else
            return cfg_1.GveMapType < cfg_2.GveMapType
        end
    else
        return cfg_1.GveMapLevel > cfg_2.GveMapLevel
    end
end
--endregion 地块

--region 协议 
--enterWorld GVE系统数据
function SlgGvE_Model.SyncSlgGvEInfo(info)
    private.InitOfficialInfo(info.official)
    private.InitTalentInfo(info.talent)
    private.InitMaterialInfo(info.material)
    private.InitTeamInfo(info.team)
    private.privilegeEndTime = info.privilegeEndTime
end

--初始化官爵任务信息
function private.InitOfficialInfo(official)
    logging.log(LTAG.LOG,"初始化官爵信息 ", official.taskInfo)
    private.officialLv = official.level 
    private.rewardMaxLevel = official.rewardMaxLevel 
    table.clear(private.officialTaskInfoMap)
    table.clear(private.officialTaskInfoList)
    for _, info in ipairs(official.taskInfo) do
        private.officialTaskInfoMap[info.level] = {}
        private.officialTaskInfoList[info.level] = {}

        local taskRecordMap = NetManager.ChangeProtoMapToLua(info.taskRecord)
        local taskState = NetManager.ChangeProtoMapToLua(info.taskState)
        local taskInfo = private.officialTaskInfoMap[info.level]

        for key, value in pairs(taskRecordMap) do
            if not taskInfo[key] then
                taskInfo[key] = {}
            end
            taskInfo[key].curProgresss = value
            taskInfo[key].taskState = taskState[key]
            taskInfo[key].taskCfg = DataSheetManager.SlgGvEOfficialTask:GetDataByOfficialQuestID(key)
            table.insert(private.officialTaskInfoList[info.level], {taskId = key, taskLv = info.level})
        end
        table.sort(private.officialTaskInfoList[info.level], SortTaskInfoList)
    end

end

--初始化天赋信息
function private.InitTalentInfo(talentInfo)
    logging.log(LTAG.LOG,"初始化天赋信息 ", talentInfo)
    table.clear(private.talentInfoMap)
    for _, talentId in ipairs(talentInfo.talentId) do
        local talentCfg = DataSheetManager.SlgGvETalentData:GetDataByGveTalentID(talentId)
        if not private.talentInfoMap[talentCfg.FrontHonorTitleID] then
            private.talentInfoMap[talentCfg.FrontHonorTitleID] = {}
        end
        table.insert(private.talentInfoMap[talentCfg.FrontHonorTitleID], {talentId = talentId, talentCfg = talentCfg})
    end

    for _, talentList in pairs(private.talentInfoMap) do
        table.sort(talentList, SortTalentInfoList)
    end

    private.UpdateTalentBuff(talentInfo.buff)
end

--初始化材料
function private.InitMaterialInfo(materialInfo)
    logging.log(LTAG.LOG,"初始化材料 ", materialInfo)
    table.clear(private.materialInfoMap)
    for _, info in ipairs(materialInfo) do
        private.materialInfoMap[info.id] = {}
        private.materialInfoMap[info.id].num = info.num
        private.materialInfoMap[info.id].gainSpeed = info.gainSpeed
    end
end

--初始化队伍信息
function private.InitTeamInfo(teamInfo)
    logging.log(LTAG.LOG,"初始化队伍 ", teamInfo)
    table.clear(private.teamInfoMap)
    for _, info in ipairs(teamInfo) do
        private.teamInfoMap[info.teamId] = {}
        private.teamInfoMap[info.teamId].teamEnergy = info.teamEnergy
        private.teamInfoMap[info.teamId].injuryEndTime = info.injuryEndTime 
    end
end

--初始化赛季信息
function SlgGvE_Model.SyncSeasonInfo(gveSeasonInfo)
    private.UpdateSeasonInfo(gveSeasonInfo)
end

function private.UpdateSeasonInfo(gveSeasonInfo)
    logging.log(LTAG.LOG,"赛季信息 ", gveSeasonInfo)
    private.seasonState = gveSeasonInfo.seasonState
    private.seasonStartTime = gveSeasonInfo.seasonStartTime
    private.seasonEndTime = gveSeasonInfo.seasonEndTime
    private.seasonShowTime = gveSeasonInfo.seasonShowTime
    private.rankSerTyp = gveSeasonInfo.rankSerTyp
    private.rankFuncOpenTime = gveSeasonInfo.rankFuncOpenTime
end

function SlgGvE_Model.SetAttackingCityOrBossInfo(gveClientShowLandInfo)
    if gveClientShowLandInfo.landId == 0 then
        table.clear(private.attackingCityOrBossInfo)
        logging.log(LTAG.LOG,"初始化城池boss,倒计时结束")
    else
        private.attackingCityOrBossInfo.landId = gveClientShowLandInfo.landId
        private.attackingCityOrBossInfo.deadLine = gveClientShowLandInfo.resetDeadLine
        logging.log(LTAG.LOG,"初始化有人开始攻打城池boss", private.attackingCityOrBossInfo)
    end
end

--playerChange增量更新, 跨赛季全量更新
function SlgGvE_Model.UpdateSlgGvEInfo(info)
    if info.isIncrement then  --增量更新
        if IsProtoDataNotNil(info.official) then
            private.UpdateOfficialInfo(info.official)
        end
        if IsProtoDataNotNil(info.talent) and IsProtoDataNotNil(info.talent.talentId) and #info.talent.talentId>0 then
            private.UpdateTalentInfo(info.talent)
        end
        if IsProtoDataNotNil(info.material) then
            private.UpdateMaterialInfo(info.material)
        end
        if IsProtoDataNotNil(info.team) then
            private.UpdateTeamInfo(info.team)
        end
    else
        private.InitOfficialInfo(info.official)
        private.InitTalentInfo(info.talent)
        private.InitMaterialInfo(info.material)
        private.InitTeamInfo(info.team)
    end
    if private.privilegeEndTime ~= info.privilegeEndTime then
        private.privilegeEndTime = info.privilegeEndTime
        EventSystem.Dispatch(EventID.UI_SlgGvE_Update_PrivilegeEndTime)
    end
end

function private.UpdateOfficialInfo(official)
    logging.log(LTAG.LOG,"增量更新官爵信息 ", official)
    private.officialLv = official.level
    private.rewardMaxLevel = official.rewardMaxLevel 
    local gveOfficialTaskInfos = official.taskInfo
    if gveOfficialTaskInfos and #gveOfficialTaskInfos > 0 then
        for _, info in ipairs(gveOfficialTaskInfos) do
            local taskRecordMap = NetManager.ChangeProtoMapToLua(info.taskRecord)
            local taskState = NetManager.ChangeProtoMapToLua(info.taskState)
            if not private.officialTaskInfoMap[info.level] then
                private.officialTaskInfoMap[info.level] = {}
            end
            local taskInfo = private.officialTaskInfoMap[info.level]
            local newLvTask = false     --是否解锁新官爵任务列表
            for key, value in pairs(taskRecordMap) do
                if not taskInfo[key] then
                    taskInfo[key] = {}
                end
                taskInfo[key].curProgresss = value
                taskInfo[key].taskState = taskState[key]
                taskInfo[key].taskCfg = DataSheetManager.SlgGvEOfficialTask:GetDataByOfficialQuestID(key)
                if not private.officialTaskInfoList[info.level] then
                    private.officialTaskInfoList[info.level] = {}
                    newLvTask = true
                end
                if newLvTask then
                    table.insert(private.officialTaskInfoList[info.level], {taskId = key, taskLv = info.level})
                end
            end
            table.sort(private.officialTaskInfoList[info.level], SortTaskInfoList)
        end
    end
    
    EventSystem.Dispatch(EventID.UI_SlgGvE_Official_Update_Info)
end

function private.UpdateTalentInfo(talentInfo)
    logging.log(LTAG.LOG,"增量更新天赋 ", talentInfo)
    for _, talentId in ipairs(talentInfo.talentId) do
        local talentCfg = DataSheetManager.SlgGvETalentData:GetDataByGveTalentID(talentId)
        local talentList = private.talentInfoMap[talentCfg.FrontHonorTitleID]
        for i, v in ipairs(talentList) do
            if v.talentCfg.GveTalentGroupID == talentCfg.GveTalentGroupID then
                talentList[i] = {talentId = talentId, talentCfg = talentCfg}
                break
            end
        end
    end
    private.UpdateTalentBuff(talentInfo.buff)
    EventSystem.Dispatch(EventID.UI_SlgGvE_Talent_Update_Info)
end

function private.UpdateTalentBuff(buff)
    private.talentEnergyLimit = buff.energyLimit
    private.talentPlotLimit = buff.plotLimit
    private.isCanBorrowRoad = buff.borrowRoad
end

function private.UpdateMaterialInfo(materialInfo)
    logging.log(LTAG.LOG,"增量更新材料 ", materialInfo)
    for _, info in ipairs(materialInfo) do
        if not private.materialInfoMap[info.id] then
            private.materialInfoMap[info.id] = {}
        end
        private.materialInfoMap[info.id].num = info.num
        private.materialInfoMap[info.id].gainSpeed = info.gainSpeed
    end
    EventSystem.Dispatch(EventID.UI_SlgGvE_Material_Update_Info)
end

function private.UpdateTeamInfo(teamInfo)
    logging.log(LTAG.LOG,"增量更新队伍 ", teamInfo)
    for _, info in ipairs(teamInfo) do
        if not private.teamInfoMap[info.teamId] then
            private.teamInfoMap[info.teamId] = {}
        end
        private.teamInfoMap[info.teamId].teamEnergy = info.teamEnergy
        private.teamInfoMap[info.teamId].injuryEndTime = info.injuryEndTime       
    end
    EventSystem.Dispatch(EventID.UI_SlgGvE_Team_Update_Info)
end

function SlgGvE_Model.UpdateSeasonInfo(gveSeasonInfo)
    private.UpdateSeasonInfo(gveSeasonInfo)
    if SlgGvE_Model.GetSeasonState() == SlgGvE_Model.SeasonState.End then
        private.OnSeasonEnd()
    elseif SlgGvE_Model.GetSeasonState() == SlgGvE_Model.SeasonState.Showing then
        private.OnSeasonShowing()
    elseif SlgGvE_Model.GetSeasonState() == SlgGvE_Model.SeasonState.Playing then
        private.OnSeasonStart()
    end
    EventSystem.Dispatch(EventID.UI_SlgGvE_SeasonTime_Update)
end

--赛季结束，执行一些清理工作
function private.OnSeasonEnd()
    SlgGvE_Model.ClearAllGrid()
    CTL.SlgGvE.CloseAllPopUpUI()
    CTL.SlgGvE.MarkGridIndex(nil, false)
end

--赛季开启，踢出停留在界面的玩家
function private.OnSeasonStart()
    if UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UISlgGvEMain) then
        UIManager.CloseView(Const_UI_Lua.UIEnum.UISlgGvEMain)
        CTL.SlgGvE.CloseAllPopUpUI()
        CTL.SlgGvE.MarkGridIndex(nil, false)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_SlgGve_Season_Hint_10"])
    end
end

--赛季进入展示期
function private.OnSeasonShowing()
    CTL.SlgGvE.CloseAllPopUpUI()
    CTL.SlgGvE.MarkGridIndex(nil, false)
    --展示期清理数据
    for i, v in DataSheetManager.SlgGvEPlotPosition:GetEnumerator() do
        local info = private.gridInfoDict[v.GveMapPlotPosition[1]]
        if info then
            if info.hasEnemy ~= nil then
                info.hasEnemy = false
            end
            info.resetDeadLine = 0
            if info.rebornTime ~= nil then
                info.rebornTime = 0
            end
            info.attackState = false
        end
    end
    EventSystem.Dispatch(EventID.UI_SlgGve_UpdateGridInfo)
end

function SlgGvE_Model.UpdateAttackingCityOrBossInfo(gveClientShowLandInfo)
    if gveClientShowLandInfo.landId == 0 then
        table.clear(private.attackingCityOrBossInfo)
    else
        private.attackingCityOrBossInfo.landId = gveClientShowLandInfo.landId
        private.attackingCityOrBossInfo.deadLine = gveClientShowLandInfo.resetDeadLine
    end
    CTL.SlgGvE.RefreshInfoReminder()
end

function SlgGvE_Model.GVEOfficialLevelUpReq()
    local msg = NetManager.GetPB("gve_op_pb").GVEOfficialLevelUpReq()
    NetManager.SendMessage(MessageEnums.MessageGVEOfficialLevelUp, msg)
end

function SlgGvE_Model.GVEOfficialTaskRewardReq(taskId)
    local msg = NetManager.GetPB("gve_op_pb").GVEOfficialTaskRewardReq()
    msg.TaskID = taskId
    NetManager.SendMessage(MessageEnums.MessageGVEOfficialTaskReward, msg)
end

function SlgGvE_Model.GVETalentLevelUpReq(talentID)
    local msg = NetManager.GetPB("gve_op_pb").GVETalentLevelUpReq()
    msg.TalentID = talentID
    NetManager.SendMessage(MessageEnums.MessageGVETalentLevelUp, msg)
end

function private.GVETalentLevelUpResp(msgResp)
    if msgResp.Resp.Code == 0 then
        local talentCfg = DataSheetManager.SlgGvETalentData:GetDataByGveTalentID(msgResp.TalentID)
        if talentCfg.GveTalentLevel > 1 then
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_SlgGve_Talent_Hint_14"])
        else
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_SlgGve_Talent_Hint_15"])
        end
        EventSystem.Dispatch(EventID.UI_SlgGve_Talent_UpLv)
    end
end

function SlgGvE_Model.GVETradeReq(itemId, itemNum, convertItemId)
    local msg = NetManager.GetPB("gve_op_pb").GVETradeReq()
    msg.itemId = itemId
    msg.itemNum = itemNum
    msg.convertItemId = convertItemId
    NetManager.SendMessage(MessageEnums.MessageGVETrade, msg)
end

function private.GVETradeResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SlgGve_Material_Trade) 
    end
end

function SlgGvE_Model.GVEMainPanelReq(isOpen)
    local msg = NetManager.GetPB("gve_op_pb").GVEMainPanelReq()
    msg.isOpen = isOpen
    NetManager.SendMessage(MessageEnums.MessageGVEMainPanel, msg)
end

function private.GVEMainPanelResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.UpdateGridInfo(msgResp.landInfoInView.personalLandInfo, msgResp.landInfoInView.eliteLandInfo, msgResp.landInfoInView.bossLandInfo)
        EventSystem.Dispatch(EventID.UI_SlgGve_SelectGridIndex, msgResp.centerPointIndex)
    else
        --关闭主界面
        UIManager.CloseView(Const_UI_Lua.UIEnum.UISlgGvEMain)
    end
end

function SlgGvE_Model.GVEGiveUpLandReq(pointIndex)
    private.giveUpGridIndex = pointIndex
    local msg = NetManager.GetPB("gve_op_pb").GVEGiveUpLandReq()
    msg.pointIndex = pointIndex
    NetManager.SendMessage(MessageEnums.MessageGVEGiveUpLand, msg)
end

function private.GVEGiveUpLandResp(msgResp)
    if msgResp.Resp.Code == 0 then
        private.RemoveMyOccupyGrid(private.giveUpGridIndex)
        --更新tips
        EventSystem.Dispatch(EventID.UI_SlgGve_UpdateGridTips, private.giveUpGridIndex)
    end
    private.giveUpGridIndex = nil
end

function private.G2CGVELandInfoChange(msgResp)
    private.UpdateGridInfo(msgResp.personalLandInfo, msgResp.eliteLandInfo, msgResp.bossLandInfo)
end

function SlgGvE_Model.GVELandMarkReq(landId, markContent)
    local msg = NetManager.GetPB("gve_op_pb").GVELandMarkReq()
    msg.landId = landId
    msg.markContent = markContent
    NetManager.SendMessage(MessageEnums.MessageGVELandMark, msg)
end

function SlgGvE_Model.GVEGetLandDetailReq(pointIndex)
    local _, info = SlgGvE_Model.GetGridInfo(pointIndex)
    if info.gveMapID == nil then
        return
    end
    local msg = NetManager.GetPB("gve_op_pb").GVEGetLandDetailReq()
    msg.pointIndex = pointIndex
    msg.landId = info.gveMapID
    NetManager.SendMessage(MessageEnums.MessageGVEGetLandDetail, msg)
end

function private.GVEGetLandDetailResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SlgGve_GetGridDetail, msgResp)
    end
end

function SlgGvE_Model.GVEPersonalLandSweepReq(teamId, pointIndex)
    local msg = NetManager.GetPB("gve_op_pb").GVEPersonalLandSweepReq()
    msg.landIndex = pointIndex
    msg.teamId = teamId
    NetManager.SendMessage(MessageEnums.MessageGVEPersonalLandSweep, msg)
end

function private.GVEPersonalLandSweepResp(msgResp)
    if msgResp.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_ResourcesChapter_RewardReminder_2)
    end
end

function SlgGvE_Model.GVEGetLastSeasonBeatRecordReq()
    local msg = NetManager.GetPB("gve_op_pb").GVEGetLastSeasonBeatRecordReq()
    msg.guildId = MDL.Guild.GetMyGuildId()
    NetManager.SendMessage(MessageEnums.MessageGVEGetLastSeasonBeatRecord, msg)
end

function private.GVEGetLastSeasonBeatRecordResp(msgResp)
    if msgResp.Resp.Code == 0 then
        EventSystem.Dispatch(EventID.UI_SlgGve_LastSeasonBeatRecord, msgResp.city.beatCity)
    end
end

function SlgGvE_Model.EnterFubenReq(levelID, freeLineUpNum, battleType, plotId, pointIndex, plotType)
    local msg = NetManager.GetPB("fuben_pb").EnterFubenReq()
    msg.mapType = LuaConst.LevelType.SlgGvE 
    msg.id = levelID
    msg.freeLineUpNum = freeLineUpNum           
    msg.gveInfo.battleType = battleType         --战斗类型 1-贼兵 2-守军
    msg.gveInfo.plotId = plotId                 --地块id
    msg.gveInfo.pointIndex = pointIndex         --地块点位
    msg.gveInfo.plotType = plotType             --地块类型
    NetManager.SendMessage(MessageEnums.MessageEnterFuben, msg)
end
--endregion 协议

return SlgGvE_Model