local uiCtrl = require_ex('UI/Panels/Base/UICtrl')
local PANEL_ID = PanelId.BattlePassTask


































































BattlePassTaskCtrl = HL.Class('BattlePassTaskCtrl', uiCtrl.UICtrl)







BattlePassTaskCtrl.s_messages = HL.StaticField(HL.Table) << {
    [MessageConst.ON_BATTLE_PASS_TASK_UPDATE] = '_OnTaskUpdate',
    [MessageConst.ON_BATTLE_PASS_TASK_BASIC_INFO_UPDATE] = '_OnBasicInfoUpdate',
    [MessageConst.ON_DAILY_ACTIVATION_MODIFY] = '_OnDailyActivationModify',
}





BattlePassTaskCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
    self:_InitViews(arg)
    self:_LoadData(true)
    self:_RenderViews()
end


BattlePassTaskCtrl.m_labelInfos = HL.Field(HL.Any)


BattlePassTaskCtrl.m_subLabelInfos = HL.Field(HL.Any)


BattlePassTaskCtrl.m_showInGroup = HL.Field(HL.Boolean) << false


BattlePassTaskCtrl.m_taskGroups = HL.Field(HL.Any)


BattlePassTaskCtrl.m_taskViewModels = HL.Field(HL.Any)


BattlePassTaskCtrl.m_taskForecastTipId = HL.Field(HL.String) << ''


BattlePassTaskCtrl.m_taskForecastTipPriority = HL.Field(HL.Number) << -99999


BattlePassTaskCtrl.m_selectedLabelIndex = HL.Field(HL.Number) << -1


BattlePassTaskCtrl.m_selectedSubLabelIndex = HL.Field(HL.Number) << -1


BattlePassTaskCtrl.m_isLifeTime = HL.Field(HL.Boolean) << false


BattlePassTaskCtrl.m_isLifeTimeComplete = HL.Field(HL.Boolean) << false


BattlePassTaskCtrl.m_labelCacheFunc = HL.Field(HL.Function)


BattlePassTaskCtrl.m_subLabelCacheFunc = HL.Field(HL.Function)


BattlePassTaskCtrl.m_subLabelNaviGroupId = HL.Field(HL.Number) << 1


BattlePassTaskCtrl.m_taskCacheFunc = HL.Field(HL.Function)


BattlePassTaskCtrl.m_viewedTasks = HL.Field(HL.Any) << nil


BattlePassTaskCtrl.m_subLabelFocus = HL.Field(HL.Boolean) << false


BattlePassTaskCtrl.m_naviTaskTarget = HL.Field(HL.Any) << nil



BattlePassTaskCtrl.OnShow = HL.Override() << function(self)
    self:_NaviResume()
end



BattlePassTaskCtrl.OnHide = HL.Override() << function(self)
    self:_ReadShowingTasks()
end



BattlePassTaskCtrl.OnClose = HL.Override() << function(self)
    self:_ReadShowingTasks()
end




BattlePassTaskCtrl.OnPhaseRefresh = HL.Override(HL.Any) << function(self, arg)
    
end

local TASK_VIEW_TYPE = {
    GROUP_TITLE = 1,
    TASK = 2,
    FORECAST = 3,
}




BattlePassTaskCtrl._InitViews = HL.Method(HL.Any) << function(self, arg)
    local naviGroupIds = {}
    table.insert(naviGroupIds, self.view.inputGroup.groupId)
    if arg ~= nil and arg.baseNaviGroupId ~= nil then
        table.insert(naviGroupIds, arg.baseNaviGroupId)
    end
    self.view.controllerHintPlaceholder:InitControllerHintPlaceholder(naviGroupIds)
    UIUtils.bindHyperlinkPopup(self, "bpTask", self.view.inputGroup.groupId)
    self.m_labelCacheFunc = UIUtils.genCachedCellFunction(self.view.labelScrollList)
    self.view.labelScrollList.onUpdateCell:RemoveAllListeners()
    self.view.labelScrollList.onUpdateCell:AddListener(function(obj, csIndex)
        self:_RenderLabel(self.m_labelCacheFunc(obj), LuaIndex(csIndex))
    end)
    self.m_subLabelCacheFunc = UIUtils.genCachedCellFunction(self.view.subLabelScrollList)
    self.view.subLabelScrollList.onUpdateCell:RemoveAllListeners()
    self.view.subLabelScrollList.onUpdateCell:AddListener(function(obj, csIndex)
        self:_RenderSubLabel(self.m_subLabelCacheFunc(obj), LuaIndex(csIndex))
    end)
    self.m_taskCacheFunc = UIUtils.genCachedCellFunction(self.view.taskScrollList)
    self.view.taskScrollList.onUpdateCell:RemoveAllListeners()
    self.view.taskScrollList.onUpdateCell:AddListener(function(obj, csIndex)
        self:_RenderTask(self.m_taskCacheFunc(obj), LuaIndex(csIndex))
    end)
    self.view.taskScrollList.getCellSize = function(csIndex)
        local luaIndex = LuaIndex(csIndex)
        local viewModel = self.m_taskViewModels[luaIndex]
        if viewModel == nil then
            return 0
        end
        if viewModel.viewType == TASK_VIEW_TYPE.GROUP_TITLE then
            return self.view.config.TASK_GROUP_TITLE_HEIGHT
        elseif viewModel.viewType == TASK_VIEW_TYPE.TASK then
            return self.view.config.TASK_CELL_HEIGHT
        elseif viewModel.viewType == TASK_VIEW_TYPE.FORECAST then
            return self.view.config.TASK_FORECAST_HEIGHT
        end
        return 0
    end
    self.view.goBtn.onClick:RemoveAllListeners()
    self.view.goBtn.onClick:AddListener(function()
        PhaseManager:GoToPhase(PhaseId.AdventureBook, {
            panelId = 'AdventureDaily',
        })
    end)
    self.view.receiveBtn.onClick:RemoveAllListeners()
    self.view.receiveBtn.onClick:AddListener(function()
        self:_TakeAllTaskReward()
    end)
    self:_InitSubLabelNavi()
end



BattlePassTaskCtrl._InitSubLabelNavi = HL.Method() << function(self)
    self.m_subLabelNaviGroupId = InputManagerInst:CreateGroup(self.view.inputGroup.groupId)
    UIUtils.bindInputPlayerAction("bp_task_sublabel_next", function()
        local subLabelCount = #self.m_subLabelInfos
        if subLabelCount <= 1 then
            return
        end
        local targetIndex = math.min(self.m_selectedSubLabelIndex + 1, subLabelCount)
        if targetIndex == self.m_selectedSubLabelIndex then
            return
        end
        self:_NaviToTargetIndex(targetIndex)
    end, self.m_subLabelNaviGroupId)
    UIUtils.bindInputPlayerAction("bp_task_sublabel_prev", function()
        local subLabelCount = #self.m_subLabelInfos
        if subLabelCount <= 1 then
            return
        end
        local targetIndex = math.max(self.m_selectedSubLabelIndex - 1, 1)
        if targetIndex == self.m_selectedSubLabelIndex then
            return
        end
        self:_NaviToTargetIndex(targetIndex)
    end, self.m_subLabelNaviGroupId)
    InputManagerInst:ToggleGroup(self.m_subLabelNaviGroupId, true)
    self.view.taskScrollListSelectableNaviGroup.onIsFocusedChange:AddListener(function(isFocused)
        self.m_subLabelFocus = isFocused
        if not isFocused then
            self.m_naviTaskTarget = nil
        end
    end)
    self.view.taskScrollListSelectableNaviGroup.onSetLayerSelectedTarget:AddListener(function(target)
        self.m_subLabelFocus = true
        self.m_naviTaskTarget = target
    end)
    self.view.taskScrollListSelectableNaviGroup.getDefaultSelectableFunc = function()
        self.view.taskScrollList:ScrollToIndex(0, true)
        for index, viewModel in ipairs(self.m_taskViewModels) do
            if viewModel.viewType == TASK_VIEW_TYPE.TASK then
                local firstCell = self.m_taskCacheFunc(index)
                if firstCell ~= nil then
                    return firstCell.naviDecorator
                end
            end
        end
    end
    self.view.labelScrollListSelectableNaviGroup.onSetLayerSelectedTarget:AddListener(function(target)
        self.m_subLabelFocus = false
        self.m_naviTaskTarget = nil
    end)
end




BattlePassTaskCtrl._NaviToTargetIndex = HL.Method(HL.Number) << function(self, targetIndex)
    self:_OnSelectSubTab(targetIndex)
    if not self.m_subLabelFocus then
        return
    end
    local firstTaskIndex = -1
    for index, viewModel in ipairs(self.m_taskViewModels) do
        if viewModel.viewType == TASK_VIEW_TYPE.TASK then
            firstTaskIndex = index
            break
        end
    end
    if firstTaskIndex > 0 then
        self.view.taskScrollList:UpdateShowingCells(function(csIndex, obj)
            local luaIndex = LuaIndex(csIndex)
            local cell = self.m_taskCacheFunc(obj)
            self:_RenderTask(cell, luaIndex)
            if luaIndex == firstTaskIndex then
                UIUtils.setAsNaviTarget(cell.naviDecorator)
            end
        end)
    end
end



BattlePassTaskCtrl._NaviResume = HL.Method() << function(self)
    local lastNaviTarget = self.m_naviTaskTarget
    self.view.labelScrollList:UpdateShowingCells(function(csIndex, obj)
        self:_RenderLabel(self.m_labelCacheFunc(obj), LuaIndex(csIndex), false)
    end)
    if lastNaviTarget ~= nil then
        UIUtils.setAsNaviTargetInSilentModeIfNecessary(self.view.taskScrollListSelectableNaviGroup, lastNaviTarget)
    end
end






BattlePassTaskCtrl._LoadData = HL.Method(HL.Opt(HL.Boolean)) << function(self, needReset)
    self:_LoadLabelData()
    if needReset == true then
        self:_ResetSelectLabel()
    end
    self:_LoadSubLabelData()
    self:_LoadGroupData()
end



BattlePassTaskCtrl._LoadLabelData = HL.Method() << function(self)
    self.m_labelInfos = {}
    local labelTable = Tables.battlePassTaskLabelTable
    local bpSystem = GameInstance.player.battlePassSystem
    for labelId, playerLabel in pairs(bpSystem.taskData.taskLabels) do
        local isSub = Tables.battlePassTaskSubLabelMapTable:ContainsKey(labelId)
        if not isSub then
            local hasLabel, labelData = labelTable:TryGetValue(labelId)
            if hasLabel then
                local labelInfo = self:_LoadLabelInfo(labelData, playerLabel)
                if labelInfo ~= nil then
                    local hasSub, subLabelMapInfo = Tables.battlePassTaskLabelMapTable:TryGetValue(labelId)
                    if hasSub then
                        local subLabelIds = {}
                        for _, subLabel in pairs(subLabelMapInfo.subLabels) do
                            table.insert(subLabelIds, subLabel.taskLabelID)
                        end
                        labelInfo.subLabelIds = subLabelIds

                        
                        local subLabelInfos = {}
                        local subEnableGroupCount = 0
                        for _, subLabelId in ipairs(subLabelIds) do
                            local hasData, subLabelData = labelTable:TryGetValue(subLabelId)
                            local hasSubLabel, playerSubLabel = bpSystem.taskData.taskLabels:TryGetValue(subLabelId)
                            if hasData and hasSubLabel then
                                local subLabelInfo = self:_LoadLabelInfo(subLabelData, playerSubLabel)
                                if subLabelInfo ~= nil and subLabelInfo.enableGroupCount > 0 then
                                    subEnableGroupCount = subEnableGroupCount + subLabelInfo.enableGroupCount
                                    table.insert(subLabelInfos, subLabelInfo)
                                end
                            end
                        end
                        table.sort(subLabelInfos, Utils.genSortFunction({"statusSortId", "sortId"}, true))
                        local visibleTime = -1
                        local overrideParentLabelIndex = -1
                        if labelInfo.isTimeVisible and labelInfo.isConditionVisible then
                            for index, subLabelInfo in ipairs(subLabelInfos) do
                                if subLabelInfo.isTimeVisible and subLabelInfo.isConditionVisible and subLabelInfo.visibleTime > visibleTime then
                                    visibleTime = subLabelInfo.visibleTime
                                    overrideParentLabelIndex = index
                                end
                            end
                        end
                        if overrideParentLabelIndex > 0 then
                            labelInfo.subName = subLabelInfos[overrideParentLabelIndex].subName
                        end
                        labelInfo.subLabelInfos = subLabelInfos
                        labelInfo.enableGroupCount = subEnableGroupCount
                    end
                    labelInfo.hasSub = hasSub
                    if labelInfo.enableGroupCount > 0 then
                        table.insert(self.m_labelInfos, labelInfo)
                    end
                end
            end
        end
    end
    table.sort(self.m_labelInfos, Utils.genSortFunction({"statusSortId", "sortId"}, true))
end





BattlePassTaskCtrl._LoadLabelInfo = HL.Method(HL.Any, HL.Any).Return(HL.Table) << function(self, labelData, playerLabel)
    local labelId = labelData.labelId
    local isLabelValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckLabelVisible(labelId)
    if not isLabelValid then
        return nil
    end
    if labelData.forecastType == GEnums.BPLabelForecastType.None and (not isTimeVisible or not isConditionVisible) then
        return nil
    end
    local enableGroupCount = 0
    for _, groupId in pairs(playerLabel.groupIds) do
        if BattlePassUtils.CheckGroupEnable(groupId) then
            enableGroupCount = enableGroupCount + 1
        end
    end
    local subName = labelData.subName
    local forecastDesc = ''
    local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
    if not isTimeVisible and (labelData.forecastType == GEnums.BPLabelForecastType.Time or
            (isConditionVisible and labelData.forecastType == GEnums.BPLabelForecastType.Condition)) then
        local leftTime = UIUtils.getShortLeftTime(playerLabel.visibleTime - curServerTime)
        local leftLongTime = UIUtils.getLeftTime(playerLabel.visibleTime - curServerTime)
        subName = string.format(Language.LUA_BATTLEPASS_TASK_LABEL_TIME_LOCK_FORMAT, leftTime)
        forecastDesc = string.format(Language.LUA_BATTLEPASS_TASK_TIME_LOCK_FORMAT, leftLongTime)
    elseif not isConditionVisible and (labelData.forecastType == GEnums.BPLabelForecastType.Condition or
            (isTimeVisible and labelData.forecastType == GEnums.BPLabelForecastType.Time)) then
        subName = Language.LUA_BATTLEPASS_TASK_LABEL_CONDITION_LOCK_TIP
        forecastDesc = labelData.conditionHint
    elseif isTimeVisible and isConditionVisible and string.isEmpty(subName) then
        local playerSeason = GameInstance.player.battlePassSystem.seasonData
        local leftLongTime = UIUtils.getLeftTime(playerSeason.closeTime - curServerTime)
        subName = string.format(Language.LUA_BATTLEPASS_TASK_LABEL_TIME_LEFT_SUB_NAME_FORMAT, leftLongTime)
    end
    local statusSortId = 0
    if not isTimeVisible or not isConditionVisible then
        statusSortId = 1
    end

    local labelInfo = {
        labelId = labelId,
        name = labelData.name,
        subName = subName,
        sortId = labelData.sortId,
        statusSortId = statusSortId,
        forecastType = labelData.forecastType,
        forecastDesc = forecastDesc,
        isTimeVisible = isTimeVisible,
        isConditionVisible = isConditionVisible,
        visibleTime = playerLabel.visibleTime,
        groupIds = playerLabel.groupIds,
        isLifeTime = labelData.isLifeTime,
        enableGroupCount = enableGroupCount,
    }
    return labelInfo
end



BattlePassTaskCtrl._ResetSelectLabel = HL.Method() << function(self)
    if self.m_labelInfos ~= nil and #self.m_labelInfos > 0 then
        self.m_selectedLabelIndex = 1
    else
        self.m_selectedLabelIndex = -1
    end
    self.m_selectedSubLabelIndex = 1
end



BattlePassTaskCtrl._LoadSubLabelData = HL.Method() << function(self)
    self.m_subLabelInfos = {}
    if self.m_selectedLabelIndex <= 0 then
        return
    end
    local parentLabelInfo = self.m_labelInfos[self.m_selectedLabelIndex]
    if parentLabelInfo == nil or parentLabelInfo.subLabelInfos == nil then
        return
    end
    self.m_subLabelInfos = parentLabelInfo.subLabelInfos
end



BattlePassTaskCtrl._LoadGroupData = HL.Method() << function(self)
    self.m_taskGroups = {}
    self.m_taskViewModels = {}
    self.m_taskForecastTipId = ''
    self.m_taskForecastTipPriority = -99999
    if self.m_selectedLabelIndex <= 0 then
        return
    end
    local labelInfo = self.m_labelInfos[self.m_selectedLabelIndex]
    if self.m_subLabelInfos ~= nil and #self.m_subLabelInfos > 0 then
        labelInfo = self.m_subLabelInfos[self.m_selectedSubLabelIndex]
    end
    
    if labelInfo == nil or (not labelInfo.isTimeVisible or not labelInfo.isConditionVisible) then
        self:_GenerateTaskViewModels()
        return
    end
    self.m_taskGroups, self.m_taskForecastTipId, self.m_taskForecastTipPriority = self:_LoadGroupDataImpl(labelInfo)
    self.m_isLifeTime = false
    self.m_isLifeTimeComplete = false
    local selectLabelInfo = self.m_labelInfos[self.m_selectedLabelIndex]
    if selectLabelInfo ~= nil then
        self.m_isLifeTime = selectLabelInfo.isLifeTime
        if self.m_isLifeTime then
            self.m_isLifeTimeComplete = true
        end
        for _, groupInfo in pairs(self.m_taskGroups) do
            self.m_isLifeTimeComplete = self.m_isLifeTimeComplete and groupInfo.isAllComplete
        end
    end
    self:_GenerateTaskViewModels()
end




BattlePassTaskCtrl._LoadGroupDataImpl = HL.Method(HL.Any).Return(HL.Table, HL.String, HL.Number) << function(self, labelInfo)
    local taskGroups = {}
    local taskForecastTipId = ''
    local taskForecastTipPriority = -99999
    local groupTable = Tables.battlePassTaskGroupTable
    local bpSystem = GameInstance.player.battlePassSystem
    for _, groupId in pairs(labelInfo.groupIds) do
        local hasGroup, groupData = groupTable:TryGetValue(groupId)
        local hasPlayer, playerGroup = bpSystem.taskData.taskGroups:TryGetValue(groupId)
        if hasGroup and hasPlayer then
            local groupInfo, forecastId, forecastPriority = self:_LoadGroupInfo(groupData, playerGroup)
            if groupInfo ~= nil then
                table.insert(taskGroups, groupInfo)
            end
            if not string.isEmpty(forecastId) then
                if forecastPriority > taskForecastTipPriority then
                    taskForecastTipId = forecastId
                    taskForecastTipPriority = forecastPriority
                end
            end
        end
    end
    table.sort(taskGroups, Utils.genSortFunction({"defaultSortId", "sortId"}, true))
    return taskGroups, taskForecastTipId, taskForecastTipPriority
end





BattlePassTaskCtrl._LoadGroupInfo = HL.Method(HL.Any, HL.Any).Return(HL.Table, HL.String, HL.Number) << function(self, groupData, playerGroup)
    local groupId = groupData.groupId
    local isGroupValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckGroupVisible(groupId)
    local taskForecastTipId = ''
    local taskForecastTipPriority = -99999
    if not isGroupValid then
        return nil, taskForecastTipId, taskForecastTipPriority
    end
    local groupTask = {}
    local taskTable = Tables.battlePassTaskTable
    local bpSystem = GameInstance.player.battlePassSystem
    local isAllComplete = true
    for _, taskId in pairs(playerGroup.taskIds) do
        local hasTask, taskData = taskTable:TryGetValue(taskId)
        local hasPlayer, playerTask = bpSystem.taskData.taskInfos:TryGetValue(taskId)
        if hasTask and hasPlayer then
            local taskInfo, forecastId = self:_LoadTaskInfo(taskData, playerTask)
            if taskInfo ~= nil then
                table.insert(groupTask, taskInfo)
                isAllComplete = isAllComplete and (taskInfo.taskState == CS.Proto.BP_TASK_STATE.TakeReward)
            elseif not string.isEmpty(forecastId) then
                local hasForecast, forecastTipData = Tables.battlePassForecastTipTable:TryGetValue(forecastId)
                if hasForecast and forecastTipData.priority > taskForecastTipPriority then
                    taskForecastTipId = forecastId
                    taskForecastTipPriority = forecastTipData.priority
                end
            end
        end
    end
    if not isTimeVisible or not isConditionVisible then
        return nil, taskForecastTipId, taskForecastTipPriority
    end
    table.sort(groupTask, Utils.genSortFunction({"statusSortId", "sortId"}, true))
    local groupInfo = {
        groupId = groupId,
        name = groupData.name,
        sortId = groupData.sortId,
        defaultSortId = groupData.isDefault and 0 or 1,
        showAsDefault = groupData.isDefault,
        taskInfos = groupTask,
        isAllComplete = isAllComplete,
        disableTime = playerGroup.disableTime,
    }
    return groupInfo, taskForecastTipId, taskForecastTipPriority
end





BattlePassTaskCtrl._LoadTaskInfo = HL.Method(HL.Any, HL.Any).Return(HL.Table, HL.String) << function(self, taskData, playerTask)
    local taskId = taskData.taskId
    local isValid, isTimeVisible, isConditionVisible = BattlePassUtils.CheckTaskVisible(taskId)
    if not isValid then
        return nil, ''
    end
    if not isTimeVisible or not isConditionVisible then
        return nil, taskData.forecastTipId
    end
    local statusSortId = 99
    if playerTask.taskState == CS.Proto.BP_TASK_STATE.HasCompleted then
        statusSortId = 1
    elseif playerTask.taskState == CS.Proto.BP_TASK_STATE.InProcessing or playerTask.taskState == CS.Proto.BP_TASK_STATE.NotAccept then
        statusSortId = 2
    elseif playerTask.taskState == CS.Proto.BP_TASK_STATE.TakeReward then
        statusSortId = 3
    end
    local taskVal, taskTarget = self:_CheckTaskCondition(taskData, playerTask)
    local taskInfo = {
        taskId = taskId,
        name = taskData.name,
        sortId = taskData.sortId,
        statusSortId = statusSortId,
        taskState = playerTask.taskState,
        jumpId = taskData.jumpId,
        addExp = taskData.addexp,
        taskVal = taskVal,
        taskTarget = taskTarget,
    }
    return taskInfo, ''
end



BattlePassTaskCtrl._GenerateTaskViewModels = HL.Method() << function(self)
    self.m_taskViewModels = {}
    for _, groupInfo in ipairs(self.m_taskGroups) do
        if not groupInfo.showAsDefault then
            table.insert(self.m_taskViewModels, {
                viewType = TASK_VIEW_TYPE.GROUP_TITLE,
                groupInfo = groupInfo,
            })
        end
        for _, taskInfo in ipairs(groupInfo.taskInfos) do
            table.insert(self.m_taskViewModels, {
                viewType = TASK_VIEW_TYPE.TASK,
                taskInfo = taskInfo,
            })
        end
    end
    if not string.isEmpty(self.m_taskForecastTipId) then
        local hasForecast, forecastData = Tables.battlePassForecastTipTable:TryGetValue(self.m_taskForecastTipId)
        if hasForecast then
            table.insert(self.m_taskViewModels, {
                viewType = TASK_VIEW_TYPE.FORECAST,
                forecastInfo = {
                    desc = forecastData.text1,
                    subDesc = forecastData.text2
                },
            })
        end
    end
end





BattlePassTaskCtrl._CheckTaskCondition = HL.Method(HL.Any, HL.Any).Return(HL.Number, HL.Number) << function(self, taskData, playerTask)
    local taskTarget = 0
    if taskData.opType == GEnums.BoolOperator.And then
        if taskData.conditionIds.Count > 1 then
            for _, conditionId in pairs(taskData.conditionIds) do
                local hasCondition, conditionData = Tables.battlePassConditionTable:TryGetValue(conditionId)
                if hasCondition then
                    taskTarget = taskTarget + 1
                end
            end
        elseif taskData.conditionIds.Count == 1 then
            local conditionId = taskData.conditionIds[0]
            local hasCondition, conditionData = Tables.battlePassConditionTable:TryGetValue(conditionId)
            if hasCondition then
                taskTarget = conditionData.progressToCompare
            end
        end
    elseif taskData.opType == GEnums.BoolOperator.Or then
        taskTarget = 1
    end

    local taskVal = 0
    
    if playerTask.taskState == CS.Proto.BP_TASK_STATE.InProcessing then
        if taskData.opType == GEnums.BoolOperator.And then
            taskVal = playerTask.completeConditions:GetAndConditionVal()
        elseif taskData.opType == GEnums.BoolOperator.Or then
            taskVal = playerTask.completeConditions:GetOrConditionVal()
        end
    elseif playerTask.taskState == CS.Proto.BP_TASK_STATE.HasCompleted or playerTask.taskState == CS.Proto.BP_TASK_STATE.TakeReward then
        taskVal = taskTarget
    end

    return taskVal, taskTarget
end








BattlePassTaskCtrl._RenderViews = HL.Method(HL.Opt(HL.Boolean, HL.Boolean, HL.Boolean)) << function(self, refreshLabel, refreshSubLabel, refreshTask)
    local hasSub = self.m_subLabelInfos ~= nil and #self.m_subLabelInfos > 0
    local showTop = hasSub or self.m_isLifeTime
    local canTakeTaskIds = self:_QueryAllCanTakeTaskIds()
    refreshLabel = refreshLabel == true
    refreshSubLabel = refreshSubLabel == true
    refreshTask = refreshTask == true
    if not refreshLabel then
        self:_UpdateLabels()
    else
        self:_RefreshLabels()
    end
    if not refreshSubLabel then
        self:_UpdateSubLabels()
    else
        self:_RefreshSubLabels()
    end
    if not refreshTask then
        self:_UpdateTasks()
    else
        self:_RefreshTasks()
    end
    local labelInfo = self.m_labelInfos[self.m_selectedLabelIndex]
    local hasLabel = labelInfo ~= nil
    local isLabelLocked = hasLabel and (not labelInfo.isTimeVisible or not labelInfo.isConditionVisible)
    local showSubLabel = hasSub and not isLabelLocked
    if hasLabel and not isLabelLocked and self.m_subLabelInfos ~= nil and #self.m_subLabelInfos > 0 then
        labelInfo = self.m_subLabelInfos[self.m_selectedSubLabelIndex]
    end
    local isForecast = hasLabel and (not labelInfo.isTimeVisible or not labelInfo.isConditionVisible)
    if isForecast then
        self.view.promptTxt.text = labelInfo.forecastDesc
    end
    InputManagerInst:ToggleGroup(self.m_subLabelNaviGroupId, hasSub and #self.m_subLabelInfos > 1)
    self.view.rightNode:SetState(not isForecast and "Exist" or (showSubLabel and "SubLabelEmpty" or "Empty"))
    self.view.topNode:SetState((not showTop) and "Empty" or (showSubLabel and "SubLabel" or (self.m_isLifeTimeComplete and "LifeTimeComplete" or "LifeTime")))
    self.view.receiveBtn.gameObject:SetActive(not isLabelLocked and not isForecast and #canTakeTaskIds > 0)
    self:_RenderDailyPart()
end



BattlePassTaskCtrl._RenderDailyPart = HL.Method() << function(self)
    local bpSystem = GameInstance.player.battlePassSystem
    local bpAbsentCount = bpSystem.seasonData.absentCount
    local hasAbsent = bpAbsentCount > 0
    local dailyPoint = GameInstance.player.adventure.adventureBookData.dailyRewardedActivation
    local dailyMax = 0
    local expBase = 0
    local expBaseGot = 0
    for _, rewardData in pairs(Tables.dailyActivationRewardTable) do
        dailyMax = math.max(dailyMax, rewardData.activation)
        local expReward = BattlePassUtils.GetAdventureDailyBpExpBaseCount(rewardData.rewardId)
        expBase = expBase + expReward
        if dailyPoint >= rewardData.activation then
            expBaseGot = expBaseGot + expReward
        end
    end
    local expBoostRate = (Tables.battlePassConst.absentFlagBpExpRate / 1000)
    local expBoost = expBoostRate * expBase
    local expBoostGot = expBoostRate * expBaseGot
    local expFinal = hasAbsent and expBoost or expBase
    local expGotFinal = hasAbsent and expBoostGot or expBaseGot
    self.view.goBtnStateController:SetState(dailyPoint >= dailyMax and "Full" or "Progress")
    self.view.dailyTxt.text = string.format(Language.LUA_BATTLEPASS_TASK_DAILY_FORMAT, math.tointeger(expGotFinal), math.tointeger(expFinal))
    self.view.goBtn.gameObject:SetActive(Utils.isSystemUnlocked(GEnums.UnlockSystemType.AdventureBook))
end



BattlePassTaskCtrl._UpdateLabels = HL.Method() << function(self)
    self.view.labelScrollList:UpdateCount(#self.m_labelInfos, true)
end



BattlePassTaskCtrl._RefreshLabels = HL.Method() << function(self)
    self.view.labelScrollList:UpdateShowingCells(function(csIndex, obj)
        self:_RenderLabel(self.m_labelCacheFunc(obj), LuaIndex(csIndex), true)
    end)
end



BattlePassTaskCtrl._UpdateSubLabels = HL.Method() << function(self)
    self.view.subLabelScrollList:UpdateCount(#self.m_subLabelInfos, true)
end



BattlePassTaskCtrl._RefreshSubLabels = HL.Method() << function(self)
    self.view.subLabelScrollList:UpdateShowingCells(function(csIndex, obj)
        local luaIndex = LuaIndex(csIndex)
        local cell = self.m_subLabelCacheFunc(obj)
        self:_RenderSubLabel(cell, luaIndex)
        if self.m_selectedSubLabelIndex == luaIndex then
            self.view.subLabelScrollRect:AutoScrollToRectTransform(cell.transform)
        end
    end)
end



BattlePassTaskCtrl._UpdateTasks = HL.Method() << function(self)
    self.view.taskScrollList:UpdateCount(#self.m_taskViewModels, true, true)
end



BattlePassTaskCtrl._RefreshTasks = HL.Method() << function(self)
    self.view.taskScrollList:UpdateCount(#self.m_taskViewModels)
end






BattlePassTaskCtrl._RenderLabel = HL.Method(HL.Any, HL.Number, HL.Opt(HL.Boolean)) << function(self, cell, luaIndex, isRefresh)
    local isSelected = self.m_selectedLabelIndex == luaIndex
    cell.stateController:SetState(isSelected and "Select" or "Another")
    local labelInfo = self.m_labelInfos[luaIndex]
    if labelInfo ~= nil then
        local isUnlock = labelInfo.isTimeVisible and labelInfo.isConditionVisible
        cell.titleText.text = labelInfo.name
        cell.describeText.text = labelInfo.subName
        cell.lockImage.gameObject:SetActive(not isUnlock)
    end
    cell.lineImage.gameObject:SetActive(luaIndex ~= #self.m_labelInfos)
    cell.redDot:InitRedDot("BattlePassTaskLabel", labelInfo.labelId)
    cell.button.onClick:RemoveAllListeners()
    cell.button.onClick:AddListener(function()
        if self.m_selectedLabelIndex == luaIndex then
            return
        end
        self.m_selectedLabelIndex = luaIndex
        self.m_selectedSubLabelIndex = 1
        self:_ReadShowingTasks()
        self:_LoadData()
        self:_RenderViews(true)
    end)
    if isSelected and DeviceInfo.usingController and not isRefresh == true then
        UIUtils.setAsNaviTarget(cell.button)
    end
end





BattlePassTaskCtrl._RenderSubLabel = HL.Method(HL.Any, HL.Number) << function(self, cell, luaIndex)
    local subLabelInfo = self.m_subLabelInfos[luaIndex]
    if subLabelInfo ~= nil then
        cell.titleTxt.text = subLabelInfo.name
    end

    cell.redDot:InitRedDot("BattlePassTaskLabel", subLabelInfo.labelId)
    cell.stateController:SetState(luaIndex == self.m_selectedSubLabelIndex and "On" or "Off")
    cell.button.onClick:RemoveAllListeners()
    cell.button.onClick:AddListener(function()
        self:_OnSelectSubTab(luaIndex)
    end)
end





BattlePassTaskCtrl._RenderTask = HL.Method(HL.Any, HL.Number) << function(self, cell, luaIndex)
    local viewModel = self.m_taskViewModels[luaIndex]
    if viewModel == nil then
        return
    end
    if viewModel.viewType == TASK_VIEW_TYPE.GROUP_TITLE then
        cell.stateController:SetState("GroupTitle")
        self:_RenderTaskGroupTitle(cell, viewModel.groupInfo)
    elseif viewModel.viewType == TASK_VIEW_TYPE.TASK then
        cell.stateController:SetState("Task")
        self:_RenderTaskCell(cell, viewModel.taskInfo)
        cell.redDot:InitRedDot("BattlePassTaskItem", viewModel.taskInfo.taskId)
        self:_CollectShowedRedDot(viewModel.taskInfo.taskId)
    elseif viewModel.viewType == TASK_VIEW_TYPE.FORECAST then
        cell.stateController:SetState("Forecast")
        self:_RenderTaskForecast(cell, viewModel.forecastInfo)
    end
end





BattlePassTaskCtrl._RenderTaskGroupTitle = HL.Method(HL.Any, HL.Any) << function(self, cell, groupInfo)
    cell.groupNameTxt.text = groupInfo.name
    if self.m_isLifeTime then
        cell.groupTimeTxt.text = Language.LUA_BATTLEPASS_TASK_GROUP_LIFE_TIME_FORMAT
    else
        local curServerTime = DateTimeUtils.GetCurrentTimestampBySeconds()
        local leftSec = groupInfo.disableTime - curServerTime
        cell.groupTimeTxt.text = string.format(Language.LUA_BATTLEPASS_TASK_GROUP_TIME_LEFT_FORMAT, UIUtils.getLeftTime(leftSec))
    end
end






BattlePassTaskCtrl._RenderTaskCell = HL.Method(HL.Any, HL.Any) << function(self, cell, taskInfo)
    local taskVal = taskInfo.taskVal
    taskVal = math.min(taskVal, taskInfo.taskTarget)
    local progress = taskInfo.taskTarget > 0 and (taskVal / taskInfo.taskTarget) or 0
    local hasJump = not string.isEmpty(taskInfo.jumpId)
    local state = hasJump and "GoTo" or "NotGoTo"
    if taskInfo.taskState == CS.Proto.BP_TASK_STATE.HasCompleted then
        state = "Receive"
    elseif taskInfo.taskState == CS.Proto.BP_TASK_STATE.TakeReward then
        state = "End"
    end
    cell.rewardNumberTxt.text = string.format(Language.LUA_BATTLEPASS_TASK_ADD_EXP_FORMAT, taskInfo.addExp)
    cell.itemSmallRewardBlack:InitItem({id = Tables.battlePassConst.bpExpItem}, true)
    cell.descTxt:SetAndResolveTextStyle(taskInfo.name)
    cell.progressBar.value = progress
    cell.progressTxt.text = string.format(Language.LUA_BATTLEPASS_PLAN_EXP_PROGRESS_FORMAT, taskVal, taskInfo.taskTarget)
    cell.takCell:SetState(state)
    cell.goToBtn.onClick:RemoveAllListeners()
    if hasJump then
        cell.goToBtn.onClick:AddListener(function()
            if not BattlePassUtils.CheckBattlePassJumpAvail(taskInfo.jumpId) then
                Notify(MessageConst.SHOW_TOAST, Language.LUA_SYSTEM_FORBIDDEN)
                return
            end
            Utils.jumpToSystem(taskInfo.jumpId)
        end)
    end
    cell.receiveBtn.onClick:RemoveAllListeners()
    cell.receiveBtn.onClick:AddListener(function()
        self:_TakeTaskReward(taskInfo.taskId)
    end)
end






BattlePassTaskCtrl._RenderTaskForecast = HL.Method(HL.Any, HL.Any) << function(self, cell, forecastInfo)
    cell.descText.text = forecastInfo.desc
    cell.subDescTxt.text = forecastInfo.subDesc
end




BattlePassTaskCtrl._CollectShowedRedDot = HL.Method(HL.String) << function(self, id)
    if self.m_viewedTasks == nil then
        self.m_viewedTasks = {}
    end
    self.m_viewedTasks[id] = true
end



BattlePassTaskCtrl._ClearShowedRedDot = HL.Method() << function(self)
    if self.m_viewedTasks == nil then
        return
    end
    local taskIds = {}
    local bpSystem = GameInstance.player.battlePassSystem
    for id, flag in pairs(self.m_viewedTasks) do
        if flag == true and bpSystem:IsTaskUnread(id) then
            table.insert(taskIds, id)
        end
    end
    self.m_viewedTasks = {}
    if #taskIds <= 0 then
        return
    end
    bpSystem:ReadTasks(taskIds)
end




BattlePassTaskCtrl._OnSelectSubTab = HL.Method(HL.Number) << function(self, luaIndex)
    if self.m_selectedSubLabelIndex == luaIndex then
        return
    end
    self.m_selectedSubLabelIndex = luaIndex
    self:_ReadShowingTasks()
    self:_LoadGroupData()
    self:_RenderViews(true, true)
end




BattlePassTaskCtrl._TakeTaskReward = HL.Method(HL.String) << function(self, taskId)
    local taskIds = {}
    table.insert(taskIds, taskId)
    self:_TakeTaskRewards(taskIds)
end



BattlePassTaskCtrl._QueryAllCanTakeTaskIds = HL.Method().Return(HL.Table) << function(self)
    local taskIds = {}
    if #self.m_subLabelInfos > 0 then
        for _, labelInfo in ipairs(self.m_subLabelInfos) do
            local groups = self:_LoadGroupDataImpl(labelInfo)
            for _, groupInfo in ipairs(groups) do
                for _, taskInfo in ipairs(groupInfo.taskInfos) do
                    if taskInfo.taskState == CS.Proto.BP_TASK_STATE.HasCompleted then
                        table.insert(taskIds, taskInfo.taskId)
                    end
                end
            end
        end
    else
        for _, groupInfo in ipairs(self.m_taskGroups) do
            for _, taskInfo in ipairs(groupInfo.taskInfos) do
                if taskInfo.taskState == CS.Proto.BP_TASK_STATE.HasCompleted then
                    table.insert(taskIds, taskInfo.taskId)
                end
            end
        end
    end
    return taskIds
end



BattlePassTaskCtrl._ReadShowingTasks = HL.Method() << function(self)
    if self.m_taskViewModels == nil or #self.m_taskViewModels <= 0 then
        return
    end
    self:_ClearShowedRedDot()
end



BattlePassTaskCtrl._OnTaskUpdate = HL.Method() << function(self)
    self:_LoadData()
    self:_RenderViews(true, true, true)
end



BattlePassTaskCtrl._OnBasicInfoUpdate = HL.Method() << function(self)
    Notify(MessageConst.SHOW_POP_UP, {
        content = Language.LUA_BATTLE_PASS_TASK_INFO_REFRESH_POPUP,
        onConfirm = function()
            self:_LoadData(true)
            self:_RenderViews()
        end,
        hideCancel = true,
    })
end



BattlePassTaskCtrl._OnDailyActivationModify = HL.Method() << function(self)
    self:_RenderDailyPart()
end



BattlePassTaskCtrl._TakeAllTaskReward = HL.Method() << function(self)
    local taskIds = self:_QueryAllCanTakeTaskIds()
    self:_TakeTaskRewards(taskIds)
end




BattlePassTaskCtrl._TakeTaskRewards = HL.Method(HL.Table) << function(self, taskIds)
    local bpSystem = GameInstance.player.battlePassSystem
    bpSystem:SendTakeTaskRewards(taskIds)
    local needReadTasks = {}
    for _, taskId in ipairs(taskIds) do
        if bpSystem:IsTaskUnread(taskId) then
            table.insert(needReadTasks, taskId)
        end
    end
    if #needReadTasks > 0 then
        bpSystem:ReadTasks(needReadTasks)
    end
end

HL.Commit(BattlePassTaskCtrl)