local UIHeroAwaken = UIViewClass()
local EventSystem = require('Event/EventSystem')
local resonance_info = require 'Proto/resonance_info_pb'
local CONST_TASK_NO_PARAM = 42462

function UIHeroAwaken:OnOpened(context)
    UIUtils.SetActive(context.parentView.currency_Info, false)
    self:RegistSystemEvent(EventID.UI_ResonanceChange_Refresh, self.RefreshResonanceLv)
    self:RegistSystemEvent(EventID.UI_HeroAwaken_UpdateStage, self.OnStageUpdate)
    self:RegistSystemEvent(EventID.UI_HeroAwaken_GetPlayerInfo, self.UpdatePlayerInfo)
    self:RegistSystemEvent(EventID.UI_HeroAwaken_UpdateTaskInfo, self.UpdateTaskInfo)
    self:RegistSystemEvent(EventID.UI_HeroAwaken_UpdateBreakInfo, self.UpdateBreakInfo)
    self:RegistSystemEvent(EventID.UI_HeroAwaken_OnBigBreakExp, self.OnBigBreakExp)
    self:RegistSystemEvent(EventID.BagItem_Update, self.HandleBreakMat)
    self:RegistSystemEvent(EventID.FunctionUnlockUpdate, self.OnFunctionUnlockUpdate)

    for i, v in ipairs(self.group_Advanced.group_unStage) do
        self:RegistTriggerEvent(v, UIEventTriggerType.PointerDown)
        self:RegistTriggerEvent(v, UIEventTriggerType.PointerUp)
    end

    local heroData = DataSheetManager.HeroNum:GetDataByID(MDL.HeroSelect.curSelectHeroID)
    self.heroName = UIUtils.GetLocalizedTxt(Const_IDS[heroData.NameIDS])

    self.parentView = context.parentView
    self:RefreshResonanceLv()
    CTL.FormationResonance.SetSubResonanceImage(self.icon_Resonance, resonance_info.Hero_Break)

    self:UpdateStage(MDL.HeroSelect.curSelectHeroID)
    EventSystem.Dispatch(EventID.UI_HeroAwaken_ChangeAwakenShow, true)
end

function UIHeroAwaken:OnFunctionUnlockUpdate(fucId, isUnlock)
    if fucId == MDL.Unlock.FunctionType.AwakenActivity then
        if not isUnlock then
            self:OnButtonClicked(self.btn_Return)
        end
    end
end

function UIHeroAwaken:OnStageUpdate()
    local heroId = MDL.HeroSelect.curSelectHeroID
    self:UpdateStage(heroId)
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    if stage == MDL.HeroAwaken.AwakenStage.SecondFighting and CTL.HeroAwaken.GetIsOpenActivityFlag() then
        CTL.HeroAwaken.SetIsOpenActivityFlag(false)
        CTL.AwakenActivity.OpenUIAwakenActivity(heroId)
    end
end

function UIHeroAwaken:UpdateStage(heroId)
    if MDL.HeroSelect.curSelectHeroID == heroId then
        local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
        self:HandleLayout(heroId, stage)
        self:HandleMiddle(heroId, stage)
        self:HandleBottom(heroId, stage)
        self:HandleProgress(heroId, stage)
    end
end

function UIHeroAwaken:HandleLayout(heroId, stage)
    if stage == MDL.HeroAwaken.AwakenStage.SixthHasAwaken then
        UIUtils.SetActive(self.group_Exam.gameObject, false)
        UIUtils.SetActive(self.group_Advanced.gameObject, true)
        if MDL.HeroAwaken.GetNextStarData(heroId) == nil then
            --已达最大觉醒等级
            self.group_Advanced.obj_state:SetState(0)
        else
            self.group_Advanced.obj_state:SetState(1)
        end
    else
        UIUtils.SetActive(self.group_Exam.gameObject, true)
        UIUtils.SetActive(self.group_Advanced.gameObject, false)
        if stage == MDL.HeroAwaken.AwakenStage.FirstNotOpen then
            self.group_Exam.state_stage:SetState(0)
        elseif stage == MDL.HeroAwaken.AwakenStage.SecondFighting then
            self.group_Exam.state_stage:SetState(0)
        elseif stage == MDL.HeroAwaken.AwakenStage.ThirdNotAcceptTask then
            self.group_Exam.state_stage:SetState(0)
        elseif stage == MDL.HeroAwaken.AwakenStage.FourthDoingTask then
            self.group_Exam.state_stage:SetState(1)
        elseif stage == MDL.HeroAwaken.AwakenStage.FifthBeforeFinal then
            self.group_Exam.state_stage:SetState(2)
        end
    end
end

function UIHeroAwaken:HandleMiddle(heroId, stage)
    if stage == MDL.HeroAwaken.AwakenStage.FirstNotOpen then
        self:HandleCondition(heroId)
    elseif stage == MDL.HeroAwaken.AwakenStage.SecondFighting then
        self:HandleCondition(heroId)
    elseif stage == MDL.HeroAwaken.AwakenStage.ThirdNotAcceptTask then
        self:HandleCondition(heroId)
    elseif stage == MDL.HeroAwaken.AwakenStage.FourthDoingTask then
        self:HandleTaskItem(heroId)
    elseif stage == MDL.HeroAwaken.AwakenStage.FifthBeforeFinal then
        self:HandleTop1Player(heroId)
    elseif stage == MDL.HeroAwaken.AwakenStage.SixthHasAwaken then
        local curBigStar, curSmallStar = MDL.HeroAwaken.GetCurStar(heroId)
        self.group_Advanced.txt_OldStar.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_Level, curBigStar)
        self.group_Advanced.txt_NewStar.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_Level, curBigStar + 1)
        local nextData = MDL.HeroAwaken.GetNextStarData(heroId)
        if nextData == nil then
            --已达最大觉醒等级
            UIUtils.SetActive(self.group_Advanced.group_NextLevel, false)
            self:HandleBreakStarExp(heroId, true)
        else
            UIUtils.SetActive(self.group_Advanced.group_NextLevel, true)
            self.group_Advanced.txt_NextLevel.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_Level, curBigStar + 1)
            self:HandleBreakStarExp(heroId, false, curBigStar, curSmallStar)
            self.group_Advanced.txt_Title.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_LevelActivate, curBigStar + 1)
            local attrData = DataSheetManager.HeroAwakenStarAttrRepeat:GetDataByAttrRepeatID(nextData.AttrSpecial)
            for i, v in ipairs(self.group_Advanced.group_Attr) do
                if i <= #attrData.Attr_Table then
                    local attr = attrData.Attr_Table[i]
                    local attrName = DataSheetManager.AttrData:GetDataByID(attr.AttrType).Name
                    local attrValue = attr.AttrNum
                    v.text = UIUtils.GetLocalizedTxt(Const_IDS[attrName]) .. UTL.Color.FormatGreenColor("+" .. attrValue)
                else
                    local count = nextData.Talent[#nextData.Talent] or 0
                    if count > 0 then
                        v.text = UIUtils.GetLocalizedTxt(Const_IDS.IDS_HeroAwaken_TianZiSkill) .. UTL.Color.FormatGreenColor("+" .. count)
                    else
                        v.text = nil
                    end
                    break
                end
            end
        end
    end
end

function UIHeroAwaken:HandleBottom(heroId, stage)
    if stage == MDL.HeroAwaken.AwakenStage.FirstNotOpen then
        UIUtils.SetActive(self.group_Exam.btn_bottom1, true)
        UIUtils.SetActive(self.group_Exam.btn_bottom2, false)
        UIUtils.SetActive(self.group_Exam.btn_tips, false)
        UIUtils.SetLabelText(self.group_Exam.txt_bottom, Const_IDS.IDS_HeroAwaken_PreviewTips1)
        UIUtils.SetLabelText(self.group_Exam.text_btn_bottom, Const_IDS.IDS_HeroAwaken_UnlockAwaken)
        self.group_Exam.btn_bottom:SetRedPoint(CTL.HeroAwaken.GetNoticeRed(heroId))
    elseif stage == MDL.HeroAwaken.AwakenStage.SecondFighting then
        UIUtils.SetActive(self.group_Exam.btn_bottom1, false)
        UIUtils.SetActive(self.group_Exam.btn_bottom2, true)
        local player = MDL.AwakenActivity.GetStartChallengeAcid(heroId)
        if string.isNilOrEmpty(player) then
            UIUtils.SetLabelText(self.group_Exam.txt_bottom2, Const_IDS.IDS_HeroAwaken_PreviewTips4)
        else
            local info = MDL.HeroAwaken.TryGetPlayerInfo(player)
            if info then
                self.group_Exam.txt_bottom2.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_PreviewTips2, info.name)
            end
        end
        self.group_Exam.btn_bottom2:SetText(Const_IDS.IDS_HeroAwaken_GoToActivity)
        self.group_Exam.btn_bottom2:SetRedPoint(CTL.HeroAwaken.GetNoticeRed(heroId))
    elseif stage == MDL.HeroAwaken.AwakenStage.ThirdNotAcceptTask then
        UIUtils.SetActive(self.group_Exam.btn_bottom1, true)
        UIUtils.SetActive(self.group_Exam.btn_bottom2, false)
        local player = MDL.HeroAwaken.GetTop1ChallengePlayer(heroId)
        local info = MDL.HeroAwaken.TryGetPlayerInfo(player)
        if info then
            self.group_Exam.txt_bottom.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_PreviewTips3, info.name)
        end
        UIUtils.SetLabelText(self.group_Exam.text_btn_bottom, Const_IDS.IDS_HeroAwaken_UnlockAwaken)
        self.group_Exam.btn_bottom:SetRedPoint(CTL.HeroAwaken.GetNoticeRed(heroId))
        UIUtils.SetActive(self.group_Exam.btn_tips, MDL.AwakenActivity.IsOpenByHeroId(heroId))
    elseif stage == MDL.HeroAwaken.AwakenStage.FourthDoingTask then
        UIUtils.SetActive(self.group_Exam.btn_bottom1, false)
        UIUtils.SetActive(self.group_Exam.btn_bottom2, false)
    elseif stage == MDL.HeroAwaken.AwakenStage.FifthBeforeFinal then
        UIUtils.SetActive(self.group_Exam.btn_bottom1, false)
        UIUtils.SetActive(self.group_Exam.btn_bottom2, false)
        UIUtils.SetActive(self.group_Exam.btn_tips3, MDL.AwakenActivity.IsOpenByHeroId(heroId))
    elseif stage == MDL.HeroAwaken.AwakenStage.SixthHasAwaken then
        local nextData = MDL.HeroAwaken.GetNextStarData(heroId)
        if nextData then
            local curBigStar, curSmallStar = MDL.HeroAwaken.GetCurStar(heroId)
            local starData = DataSheetManager.HeroAwakenStar:GetDataByHeroID_Star(heroId, curBigStar)
            local isBigBreak = curSmallStar == #starData.Item - 1
            if isBigBreak then
                self.group_Advanced.btn_Break:SetText(Const_IDS.IDS_HeroAwaken_LevelUp2)
            else
                self.group_Advanced.btn_Break:SetText(Const_IDS.IDS_HeroAwaken_LevelUp1)
            end

            self:HandleBreakMat()
        end
    end
end

function UIHeroAwaken:HandleProgress(heroId, stage)
    if stage == MDL.HeroAwaken.AwakenStage.FirstNotOpen then
        self.group_Exam.obj_state1:SetState(1)
        self.group_Exam.obj_state2:SetState(1)
        self.group_Exam.obj_state3:SetState(1)
    elseif stage == MDL.HeroAwaken.AwakenStage.SecondFighting then
        self.group_Exam.obj_state1:SetState(0)
        self.group_Exam.obj_state2:SetState(1)
        self.group_Exam.obj_state3:SetState(1)
    elseif stage == MDL.HeroAwaken.AwakenStage.ThirdNotAcceptTask then
        self.group_Exam.obj_state1:SetState(0)
        self.group_Exam.obj_state2:SetState(1)
        self.group_Exam.obj_state3:SetState(1)
    elseif stage == MDL.HeroAwaken.AwakenStage.FourthDoingTask then
        self.group_Exam.obj_state1:SetState(0)
        self.group_Exam.obj_state2:SetState(0)
        self.group_Exam.obj_state3:SetState(1)
    elseif stage == MDL.HeroAwaken.AwakenStage.FifthBeforeFinal then
        self.group_Exam.obj_state1:SetState(0)
        self.group_Exam.obj_state2:SetState(0)
        self.group_Exam.obj_state3:SetState(0)
    end
end

function UIHeroAwaken:HandleBreakMat()
    local isEnough = true
    local heroId = MDL.HeroSelect.curSelectHeroID
    local curBigStar, curSmallStar = MDL.HeroAwaken.GetCurStar(heroId)
    local starData = DataSheetManager.HeroAwakenStar:GetDataByHeroID_Star(heroId, curBigStar)
    local itemTable = DataSheetManager.HeroAwakenStarItemRepeat:GetDataByItemRepeatID(starData.Item[curSmallStar + 1]).Item_Table
    for i, v in ipairs(self.group_Advanced.group_Item) do
        if #itemTable >= i then
            UIUtils.SetActive(v.gameObject, true)
            local itemID = itemTable[i].ItemID
            local itemNum = itemTable[i].ItemNum
            v.ItemID = itemID
            local curCount = MDL.Bag.GetItemCount(itemID)
            if curCount < itemNum then
                curCount = UTL.Color.FormatRedColor(curCount)
                isEnough = false
            end
            UTL.Item.SetItemCell(v, itemID, curCount .. "/" .. itemNum)
        else
            UIUtils.SetActive(v.gameObject, false)
        end
    end

    self.isItemEnough = isEnough
    self.group_Advanced.btn_Break:SetRedPoint(isEnough)
end

function UIHeroAwaken:HandleCondition(heroId)
    self.group_Exam.txt_Condition1.text = string.format("%s+%s", self.heroName, MDL.HeroStar.GetHeroMaxStarLevel(heroId))
    if CTL.HeroAwaken.CheckEnableAwake(heroId, CTL.HeroAwaken.AwakeConditionType.Hero) then
        self.group_Exam.state_condition1:SetState(0)
    else
        self.group_Exam.state_condition1:SetState(1)
    end
    local weaponName = DataSheetManager.MagicWeaponData:GetDataByMagicWeaponID(heroId).MagicWeaponName
    self.group_Exam.txt_Condition2.text = string.format("%s+%s", UIUtils.GetLocalizedTxt(Const_IDS[weaponName]), MDL.DivineWeapon.GetBreakMax(heroId))
    if CTL.HeroAwaken.CheckEnableAwake(heroId, CTL.HeroAwaken.AwakeConditionType.Weapon) then
        self.group_Exam.state_condition2:SetState(0)
    else
        self.group_Exam.state_condition2:SetState(1)
    end
    UIUtils.SetLabelText(self.group_Exam.txt_Condition3, Const_IDS.IDS_HeroAwaken_FoundryAwakenCondition)
    if CTL.HeroAwaken.CheckEnableAwake(heroId, CTL.HeroAwaken.AwakeConditionType.WeaponForge) then
        self.group_Exam.state_condition3:SetState(0)
    else
        self.group_Exam.state_condition3:SetState(1)
    end
end

function UIHeroAwaken:HandleTaskItem(heroId)
    self.taskDataMap = {}
    for i, v in DataSheetManager.AwakenTask:GetDataByHeroID_TaskID(heroId) do
        local item = self.group_Exam.group_TaskItem[i]
        self.taskDataMap[item] = v
        UIUtils.SetLabelText(item.text_Task, Const_IDS[v.TaskName])
        local taskState = MDL.HeroAwaken.GetTaskState(heroId, v.TaskID)
        UIUtils.SetActive(item.obj_finish, taskState == MDL.HeroAwaken.AwakenTaskState.HasFinish)
        item.btn_task:SetRedPoint(taskState == MDL.HeroAwaken.AwakenTaskState.EnoughNotFinish)
        UIUtils.SetActive(item.obj_select, false)
    end
    if self.selectTaskItem == nil then
        self:SelectTaskItem(self.group_Exam.group_TaskItem[1])
    else
        self:SelectTaskItem(self.selectTaskItem)
    end
end

function UIHeroAwaken:SelectTaskItem(selectItem)
    if self.selectTaskItem then
        UIUtils.SetActive(self.selectTaskItem.obj_select, false)
    end
    self.selectTaskItem = selectItem
    UIUtils.SetActive(selectItem.obj_select, true)
    local taskData = self.taskDataMap[selectItem]
    local triggerData = DataSheetManager.TriggerID:GetDataByID(taskData.TriggerID)
    self.group_Exam.loop_Task:ClearCells()
    local heroId = MDL.HeroSelect.curSelectHeroID
    for i, v in ipairs(triggerData.Unlock_Table) do
        local _heroId = tonumber(v.UnlockConditionParamA)
        if _heroId == heroId then
            self.group_Exam.loop_Task:AddData(v, 0)
        end
    end
    self.group_Exam.text_stage2.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_TaskButton, UIUtils.GetLocalizedTxt(Const_IDS[taskData.TaskName]))
    local taskState = MDL.HeroAwaken.GetTaskState(heroId, taskData.TaskID)
    if taskState == MDL.HeroAwaken.AwakenTaskState.HasFinish then
        self.group_Exam.state_TaskState:SetState(2)
    else
        if not CTL.HeroAwaken.IsEnableAwake(heroId) then
            self.group_Exam.state_TaskState:SetState(0)
        else
            self.group_Exam.state_TaskState:SetState(1)
            if taskState == MDL.HeroAwaken.AwakenTaskState.EnoughNotFinish then
                self.group_Exam.btn_stage2:SetRedPoint(true)
            else
                self.group_Exam.btn_stage2:SetRedPoint(false)
            end
        end
    end
end

function UIHeroAwaken:OnCellInit(scrollRect, index, cellTable, data)
    if scrollRect == self.group_Exam.loop_Task then
        local curParam = MDL.HeroAwaken.GetTaskTriggerParam(MDL.HeroSelect.curSelectHeroID, data.UnlockCondition)
        local tarParam = tonumber(data.UnlockConditionParamB)
        local progressValue
        if curParam >= tarParam then
            progressValue = UTL.Color.FormatGreenColor(curParam) .. "/" .. tarParam
            cellTable.state:SetState(0)
        else
            progressValue = UTL.Color.FormatRedColor(curParam) .. "/" .. tarParam
            cellTable.state:SetState(1)
        end
        if data.UnlockCondition == CONST_TASK_NO_PARAM then
            cellTable.txt_LimitTitle.text = string.FormatByIdsId(Const_IDS[data.UnlockConditionDes], progressValue)
        else
            cellTable.txt_LimitTitle.text = string.FormatByIdsId(Const_IDS[data.UnlockConditionDes], self.heroName, progressValue)
        end
    end
end

function UIHeroAwaken:HandleTop1Player(heroId)
    local player = MDL.HeroAwaken.GetTop1ChallengePlayer(heroId)
    local info = MDL.HeroAwaken.TryGetPlayerInfo(player)
    if info then
        CTL.Character.SetPortraitAndFrame(self.group_Exam.UIHeroHead190, info.PortraitId, info.FrameId, info.level)
        self.group_Exam.txt_playerName.text = info.name
        self.group_Exam.txt_desc3.text = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_Number1PlayerTips, info.name, info.name)
    end
end

function UIHeroAwaken:HandleBreakStarExp(heroId, isFull, bigBreak, smallBreak)
    if isFull then
        for i, v in ipairs(self.group_Advanced.group_unStage) do
            UIUtils.SetActive(v, false)
        end
        for i, v in ipairs(self.group_Advanced.group_Stage) do
            UIUtils.SetActive(v, true)
        end
        for i, v in ipairs(self.group_Advanced.group_Effect) do
            UIUtils.SetActive(v, false)
        end
        UIUtils.SetActive(self.group_Advanced.group_StageTitle, false)
        UIUtils.SetActive(self.group_Advanced.effect_hint, false)
    else
        for i, v in ipairs(self.group_Advanced.group_Stage) do
            if i == #self.group_Advanced.group_Stage then
                UIUtils.SetActive(v, smallBreak == i - 1)
                UIUtils.SetActive(self.group_Advanced.group_Effect[i], smallBreak == i - 1)
            else
                if smallBreak >= i then
                    UIUtils.SetActive(v, true)
                    UIUtils.SetActive(self.group_Advanced.group_Effect[i], true)
                else
                    UIUtils.SetActive(v, false)
                    UIUtils.SetActive(self.group_Advanced.group_Effect[i], false)
                end
            end
        end
        self:HandleStarAttr(heroId, bigBreak, smallBreak + 1)
    end
end

function UIHeroAwaken:HandleStarAttr(heroId, bigBreak, smallBreak)
    local attr = CTL.HeroAwaken.GetSmallBreakAttr(heroId, bigBreak, smallBreak)
    if not string.isNilOrEmpty(attr) and self.group_Advanced.group_unStage[smallBreak] then
        UIUtils.SetActive(self.group_Advanced.group_StageTitle, true)
        self.group_Advanced.group_StageTitle.transform:SetParent(self.group_Advanced.group_unStage[smallBreak].transform, false)
        self.group_Advanced.txt_StageAttr.text = attr
        UIUtils.SetActive(self.group_Advanced.effect_hint, true)
        self.group_Advanced.effect_hint.transform:SetParent(self.group_Advanced.group_unStage[smallBreak].transform, false)
    else
        UIUtils.SetActive(self.group_Advanced.group_StageTitle, false)
        UIUtils.SetActive(self.group_Advanced.effect_hint, false)
    end
end

function UIHeroAwaken:OnPointerDown(comp, eventData)
    local index = nil
    for i, v in ipairs(self.group_Advanced.group_unStage) do
        if v.gameObject == comp.gameObject then
            index = i
            break
        end
    end
    local heroId = MDL.HeroSelect.curSelectHeroID
    local curBigStar = MDL.HeroAwaken.GetCurStar(heroId)
    self:HandleStarAttr(heroId, curBigStar, index)
end

function UIHeroAwaken:OnPointerUp(comp, eventData)
    local heroId = MDL.HeroSelect.curSelectHeroID
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    self:HandleMiddle(heroId, stage)
end

function UIHeroAwaken:OnButtonClicked(comp)
    if comp == self.btn_Resonance then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIResonanceInfo, { subResonanceID = resonance_info.Hero_Break, isShowGoto = false })
    elseif comp == self.btn_Return then
        EventSystem.Dispatch(EventID.UI_HeroAwaken_ReturnBreak, true)
    elseif comp == self.group_Exam.btn_tips or comp == self.group_Exam.btn_tips3 then
        --前往活动
        CTL.AwakenActivity.OpenUIAwakenActivity(MDL.HeroSelect.curSelectHeroID)
    elseif comp == self.group_Exam.btn_bottom or comp == self.group_Exam.btn_bottom2 then
        self:OnClickBottomBtn()
    elseif comp == self.group_Exam.btn_stage2 then
        if self.selectTaskItem then
            local taskData = self.taskDataMap[self.selectTaskItem]
            local taskState = MDL.HeroAwaken.GetTaskState(MDL.HeroSelect.curSelectHeroID, taskData.TaskID)
            if taskState == MDL.HeroAwaken.AwakenTaskState.NotEnough then
                CTL.Tips.AddTipsMsg(Const_IDS.IDS_HeroAwaken_TaskWrongHint)
                return
            end
            MDL.HeroAwaken.FinishAwakenTaskReq(MDL.HeroSelect.curSelectHeroID, taskData.TaskID)
        end
    elseif comp == self.group_Advanced.btn_Tips2 then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIHeroAwakenBreakInfo, { type = 0, heroId = MDL.HeroSelect.curSelectHeroID }, Const_UI_Lua.UIEnum.UIHeroBreakInfoView)
    elseif comp == self.group_Advanced.btn_Break then
        if self.isItemEnough == false then
            CTL.Tips.AddTipsMsg(Const_IDS.IDS_Equip_Enchance_CoinNotEnough)
            return
        end
        MDL.HeroAwaken.AwakenHeroBreakReq(MDL.HeroSelect.curSelectHeroID)
    elseif comp == self.group_Exam.btn_stage3 then
        MDL.HeroAwaken.EnterFinalStage(MDL.HeroSelect.curSelectHeroID)
    else
        for i, v in ipairs(self.group_Advanced.group_Item) do
            if comp == v.event_Click then
                UTL.ItemTips.ShowCommonTipsById(v.ItemID)
                return
            end
        end

        for i, item in ipairs(self.group_Exam.group_Item) do
            if comp == item then
                UIManager.OpenView(Const_UI_Lua.UIEnum.UIHeroAwakenpopup, { state = i - 1, heroId = MDL.HeroSelect.curSelectHeroID })
                return
            end
        end

        for i, item in ipairs(self.group_Exam.group_TaskItem) do
            if comp == item.btn_task then
                self:SelectTaskItem(item)
                return
            end
        end
    end
end

function UIHeroAwaken:OnClickBottomBtn()
    local heroId = MDL.HeroSelect.curSelectHeroID
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    if stage == MDL.HeroAwaken.AwakenStage.FirstNotOpen then
        if CTL.HeroAwaken.IsEnableAwake(heroId) == false then
            CTL.Tips.AddTipsMsg(Const_IDS.IDS_HeroAwaken_NoEnterCondition2)
            return
        end
        local heroName = self.heroName
        local title = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_HeroUnlockAwaken, heroName)
        local content = string.FormatByIdsId(Const_IDS.IDS_HeroAwaken_PreviewTips5, heroName)
        UTL.MessageBox.ShowOKCancelBox(title, content, function()
            MDL.HeroAwaken.OpenAwakenChallengeReq(heroId)
        end)
    elseif stage == MDL.HeroAwaken.AwakenStage.SecondFighting then
        --前往活动
        CTL.AwakenActivity.OpenUIAwakenActivity(MDL.HeroSelect.curSelectHeroID)
    elseif stage == MDL.HeroAwaken.AwakenStage.ThirdNotAcceptTask then
        if CTL.HeroAwaken.IsEnableAwake(heroId) == false then
            CTL.Tips.AddTipsMsg(Const_IDS.IDS_HeroAwaken_NoEnterCondition2)
            return
        end
        MDL.HeroAwaken.StartAwakenTaskReq(heroId)
    end
end

function UIHeroAwaken:UpdatePlayerInfo()
    local heroId = MDL.HeroSelect.curSelectHeroID
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    if stage == MDL.HeroAwaken.AwakenStage.FifthBeforeFinal then
        self:HandleTop1Player(heroId)
    else
        self:HandleBottom(heroId, stage)
    end
end

function UIHeroAwaken:UpdateTaskInfo()
    local heroId = MDL.HeroSelect.curSelectHeroID
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    if stage == MDL.HeroAwaken.AwakenStage.FourthDoingTask then
        self:HandleTaskItem(heroId)
    end
end

function UIHeroAwaken:UpdateBreakInfo()
    local heroId = MDL.HeroSelect.curSelectHeroID
    local stage = MDL.HeroAwaken.GetAwakenStage(heroId)
    if stage == MDL.HeroAwaken.AwakenStage.SixthHasAwaken then
        self:HandleLayout(heroId, stage)
        self:HandleMiddle(heroId, stage)
        self:HandleBottom(heroId, stage)
    end
end

function UIHeroAwaken:RefreshResonanceLv()
    if MDL.Unlock.IsUnlock(MDL.Unlock.FunctionType.Resonance) then
        UIUtils.SetActive(self.btn_Resonance, true)
    else
        UIUtils.SetActive(self.btn_Resonance, false)
    end
    UIUtils.SetLabel(self.txt_ResonanceLv, string.FormatByIdsId(Const_IDS["IDS_Resonance_Level"], MDL.FormationResonance.GetSubResonanceLv(resonance_info.Hero_Break)))
end

function UIHeroAwaken:OnClosed()
    CTL.HeroAwaken.OnEnterAwaken(MDL.HeroSelect.curSelectHeroID)
    UIUtils.SetActive(self.context.parentView.currency_Info, true)
    EventSystem.Dispatch(EventID.UI_HeroAwaken_ChangeAwakenShow, false)
end

function UIHeroAwaken:OnBigBreakExp()
    self.group_Advanced.effect_big:PlayUIEffect()
end

return UIHeroAwaken