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














































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






CharUpgradeCtrl.m_charInfo = HL.Field(HL.Table)


CharUpgradeCtrl.m_upgradeItemCostDict = HL.Field(HL.Table)


CharUpgradeCtrl.m_expCardInfoList = HL.Field(HL.Table)


CharUpgradeCtrl.m_curGenerateExp = HL.Field(HL.Number) << 0


CharUpgradeCtrl.m_upgradeItemCellCache = HL.Field(HL.Forward("UIListCache"))


CharUpgradeCtrl.m_level2RequireExpDict = HL.Field(HL.Table)


CharUpgradeCtrl.m_level2RequireGoldDict = HL.Field(HL.Table)


CharUpgradeCtrl.m_fromLevel = HL.Field(HL.Number) << 0


CharUpgradeCtrl.m_toLevel = HL.Field(HL.Number) << 0


CharUpgradeCtrl.m_stageLevel = HL.Field(HL.Number) << 0


CharUpgradeCtrl.m_curWorldLevel = HL.Field(HL.Number) << 0


CharUpgradeCtrl.m_worldLimitLevel = HL.Field(HL.Number) << 0




CharUpgradeCtrl.m_controllerCurSelectedItemId = HL.Field(HL.String) << ""


CharUpgradeCtrl.m_upgradeItemList = HL.Field(HL.Table)


CharUpgradeCtrl.m_breakItemList = HL.Field(HL.Table)


CharUpgradeCtrl.m_itemIdToCellIndex = HL.Field(HL.Table)


CharUpgradeCtrl.m_levelUpCor = HL.Field(HL.Thread)


CharUpgradeCtrl.m_sliderTween = HL.Field(HL.Any)


CharUpgradeCtrl.m_curNaviTargetUpgradeItemCell = HL.Field(HL.Any)






CharUpgradeCtrl.s_messages = HL.StaticField(HL.Table) << {
    [MessageConst.ON_CHAR_GAIN_EXP] = 'OnCharGainExp',
    [MessageConst.ON_CHAR_LEVEL_UP] = 'OnCharLevelUp',
}





CharUpgradeCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
    local initCharInfo = arg.initCharInfo or CharInfoUtils.getLeaderCharInfo()

    self.m_charInfo = initCharInfo
    self.m_itemIdToCellIndex = {}

    self.m_upgradeItemList = {}
    self.m_breakItemList = {}

    self:_InitActionEvent()
    self:_InitCharUpgradePanel()


    
    local charInstId = initCharInfo.instId
    local curExp, levelUpExp, curLevel, stageLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)
    local isUpgrade = curLevel < stageLevel
    CS.Beyond.Lua.UtilsForLua.ToggleCharInfoInUpgradePanelOption(isUpgrade)

    self.view.controllerHintPlaceholder:InitControllerHintPlaceholder({self.view.inputGroup.groupId})
end




CharUpgradeCtrl._InitCharUpgradePanel = HL.Method() << function(self)
    self.view.upgradeNode.upgradeLevelNode.addExp.text = 0
    self.view.upgradeNode.upgradeLevelNode.addLevel.text = 0


    self.view.upgradeNode.upgradeLevelNode.addExpBar.fillAmount = 0
    self.view.breakNode.upgradeLevelNode.addExpBar.fillAmount = 0
end



CharUpgradeCtrl.OnHide = HL.Override() << function(self)
    Notify(MessageConst.HIDE_ITEM_TIPS)
end



CharUpgradeCtrl.OnClose = HL.Override() << function(self)
    if self.m_sliderTween then
        self.m_sliderTween:Kill()
    end
    CS.Beyond.Lua.UtilsForLua.ToggleCharInfoInUpgradePanelOption(false)

    Notify(MessageConst.HIDE_ITEM_TIPS)
end



CharUpgradeCtrl.OnShow = HL.Override() << function(self)
    local initCharInfo = self.m_charInfo

    self.view.walletBarPlaceholder:InitWalletBarPlaceholder(UIConst.INVENTORY_MONEY_IDS)
    self:_RefreshUpgradePanel(initCharInfo)
end




CharUpgradeCtrl.OnCharGainExp = HL.Method(HL.Table) << function(self, arg)
    self:_RefreshUpgradePanel(self.m_charInfo)
end




CharUpgradeCtrl.OnCharLevelUp = HL.Method(HL.Table) << function(self, arg)
    Utils.triggerVoice("chrup_level", self.m_charInfo.templateId)
    self.m_levelUpCor = self:_ClearCoroutine(self.m_levelUpCor)
    self.m_levelUpCor = self:_StartCoroutine(function()
        self:_RefreshUpgradePanel(self.m_charInfo, true)
    end)
end





CharUpgradeCtrl.AddUpgradeItem = HL.Method(HL.String, HL.Number) << function(self, itemId, count)
    local charInstId = self.m_charInfo.instId
    local curExp, levelUpExp, curLevel, maxLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)

    maxLevel = maxLevel > self.m_worldLimitLevel and self.m_worldLimitLevel or maxLevel
    local curGenerateExp = self:_GetCurAddOnExp()
    local needExp = self.m_level2RequireExpDict[maxLevel] or 0
    local expRequire = needExp - curExp

    if count > 0 and curGenerateExp > expRequire then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_EXHIBIT_UPGRADE_MAX_LEVEL)
        return
    end

    local addItemCount = self:_TryGetAddItemCount(curGenerateExp, expRequire, itemId, count)

    if addItemCount <= 0 then
        self.m_upgradeItemCostDict[itemId] = nil
    else
        self.m_upgradeItemCostDict[itemId] = addItemCount
    end
end







CharUpgradeCtrl._TryGetAddItemCount = HL.Method(HL.Number, HL.Number, HL.String, HL.Number).Return(HL.Number) << function(self, curGenerateExp, expRequire, itemId, count)
    local expItemDataMap = Tables.expItemDataMap
    local _, expItemData = expItemDataMap:TryGetValue(itemId)
    local exp = expItemData.expGain
    local curCount = self.m_upgradeItemCostDict[itemId] or 0
    local nextCount = curCount + count

    if count <= 0 then
        return nextCount
    end

    if (curGenerateExp + (exp * count)) > expRequire then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_EXHIBIT_UPGRADE_MAX_LEVEL)

        local needExp = math.max(0, expRequire - curGenerateExp)
        nextCount = curCount + math.ceil(needExp / exp)
    end

    local inventoryCount = Utils.getItemCount(itemId, true)
    if nextCount > inventoryCount then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_WEAPON_EXHIBIT_UPGRADE_MAX_ITEM_COUNT)

        return inventoryCount
    end

    return nextCount
end





CharUpgradeCtrl._RefreshUpgradePanel = HL.Method(HL.Table, HL.Opt(HL.Boolean)) << function(self, charInfo, isUpgradeTransition)
    local charInstId = charInfo.instId
    local curExp, levelUpExp, curLevel, stageLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)
    local isUpgrade = curLevel < stageLevel
    if isUpgradeTransition then
        if isUpgrade then
            
            AudioAdapter.PostEvent("Au_UI_Event_CharLevelUp")

            self.view.animation:Play("charupgrade_scroll_in")
            coroutine.wait(0.3)
        else
            
            AudioAdapter.PostEvent("Au_UI_Event_CharLevelUp")

            self.view.animation:Play("charupgrade_scroll_in")
            coroutine.wait(0.3)
            self:_InitUpgradeCache(charInfo)
            self:_RefreshUpgradeNode(charInfo, isUpgradeTransition)
            coroutine.wait(1.5)
            self.view.upgradeNode.animationWrapper:PlayOutAnimation()

            coroutine.wait(0.5)
            AudioAdapter.PostEvent("Au_UI_Event_CharLevelLimit")

        end
    end

    self.view.upgradeNode.gameObject:SetActive(isUpgrade)
    self.view.breakNode.gameObject:SetActive(not isUpgrade)

    CS.Beyond.Lua.UtilsForLua.ToggleCharInfoInUpgradePanelOption(isUpgrade)

    self.view.textTitle.text = CharInfoUtils.getCharInfoTitle(charInfo.templateId, UIConst.CHAR_INFO_PAGE_TYPE.UPGRADE)

    if isUpgrade then
        self:_InitUpgradeCache(charInfo)
        self:_RefreshUpgradeNode(charInfo, isUpgradeTransition)
    else
        self:_RefreshBreakNode(charInfo.instId)
    end
end





CharUpgradeCtrl._RefreshUpgradeNode = HL.Method(HL.Table, HL.Opt(HL.Boolean)) << function(self, charInfo, isUpgradeTransition)
    local charInstId = charInfo.instId
    local charInstInfo = CharInfoUtils.getPlayerCharInfoByInstId(charInstId)
    local curExp, levelUpExp, curLevel, stageLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)
    local upgradeLevelNode = self.view.upgradeNode.upgradeLevelNode
    upgradeLevelNode.stageLevel.text = stageLevel
    self.m_curWorldLevel = GameInstance.player.adventure.currentWorldLevel
    local _, worldLevelData = Tables.adventureWorldLevelTable:TryGetValue(self.m_curWorldLevel)
    local showLvLimit = false
    if worldLevelData then
        self.m_worldLimitLevel = worldLevelData.charMaxLv
        if stageLevel > self.m_worldLimitLevel then
            showLvLimit = true
            upgradeLevelNode.txtLvLimit.text = string.format(Language.LUA_WORLD_LEVEL_CHAR_LEVEL_LIMIT_FORMAT, self.m_worldLimitLevel)
        end
    end
    UIUtils.PlayAnimationAndToggleActive(upgradeLevelNode.lvLimitNode, showLvLimit)

    local curGenerateExp = self:_GetCurAddOnExp()
    local curAddExp = curGenerateExp + curExp
    local targetLevel, expLeft = self:_CalcLevelByExp(curAddExp, curLevel, stageLevel)
    local levelExpData = Tables.charLevelUpTable
    local targetLevelExp = levelExpData[targetLevel].exp
    local curLevelExp = levelExpData[curLevel].exp
    local addLevel = targetLevel - curLevel

    upgradeLevelNode.addExpIcon.gameObject:SetActive(true)
    upgradeLevelNode.addLevelIcon.gameObject:SetActive(true)

    upgradeLevelNode.nextLvExp.text = levelUpExp
    upgradeLevelNode.curExp.text = curExp

    if isUpgradeTransition then
        
        upgradeLevelNode.addLevel.text = addLevel
        upgradeLevelNode.addExp.text = curGenerateExp
        upgradeLevelNode.curLevel.tweenToText = curLevel 
    else
        
        upgradeLevelNode.addLevel.tweenToText = addLevel 
        upgradeLevelNode.addExp.text = curGenerateExp
        upgradeLevelNode.curLevel.text = curLevel
    end

    upgradeLevelNode.currentExpBar.fillAmount = targetLevel > curLevel and 0 or curExp / targetLevelExp

    local newValue = targetLevel > curLevel and 1 or expLeft / targetLevelExp
    if self.m_sliderTween then
        self.m_sliderTween:Kill()
    end
    self.m_sliderTween = DOTween.To(function()
        return upgradeLevelNode.addExpBar.fillAmount
    end, function(value)
        upgradeLevelNode.addExpBar.fillAmount = value
    end, newValue, 0.5)

    self.m_fromLevel = charInstInfo.level
    self.m_toLevel = targetLevel
    self.m_stageLevel = stageLevel

    self.m_upgradeItemCellCache:Refresh(#expCards, function(cell, index)
        local itemId = expCards[CSIndex(index)]

        self:_RefreshUpgradeItemCell(cell, itemId)
    end)

    local breakStage =  charInstInfo.breakStage
    self.view.upgradeNode.weaponAttributeNode:InitCharAttributeNode(charInstId, targetLevel, breakStage, {
        showAttrTransition = isUpgradeTransition
    })

    local curGold = Utils.getItemCount(UIConst.INVENTORY_MONEY_IDS[1], true)
    local needGold = self.m_level2RequireGoldDict[targetLevel] or 0
    self.view.upgradeNode.goldCostNumber.text = UIUtils.setCountColor(needGold, curGold < needGold)

    local isReachWorldLevelLimit = self.m_fromLevel >= self.m_worldLimitLevel
    local isMaxLevel = curLevel >= stageLevel and charInstInfo.breakStage >= Tables.characterConst.maxBreak
    self.view.upgradeNode.buttonNode.gameObject:SetActive(not isReachWorldLevelLimit)
    self.view.upgradeNode.btnAutoFill.gameObject:SetActive(not isReachWorldLevelLimit)
    self.view.upgradeNode.btnReset.gameObject:SetActive(not isReachWorldLevelLimit)
    local isShowUpgradeTips = isReachWorldLevelLimit and not isMaxLevel
    self.view.upgradeNode.upgradeTips.gameObject:SetActive(isShowUpgradeTips)
    if isShowUpgradeTips then
        
        local unlockWorldLevel = self.m_curWorldLevel + 1
        for i = unlockWorldLevel, #Tables.adventureWorldLevelTable do
            local _, worldLevelData = Tables.adventureWorldLevelTable:TryGetValue(i)
            if worldLevelData and worldLevelData.charMaxLv > self.m_worldLimitLevel then
                unlockWorldLevel = i
                break
            end
        end
        self.view.upgradeNode.upgradeTips.txtTips.text = string.format(Language.LUA_CHAR_LEVEL_UPGRADE_WORLD_LEVEL_FORMAT, unlockWorldLevel)
    end

    self:_UpdateAddAndSubBtnState()
end



CharUpgradeCtrl._GetCurAddOnExp = HL.Method().Return(HL.Number) << function(self)
    local expSum = 0
    local expItemDataMap = Tables.expItemDataMap
    for itemId, itemCount in pairs(self.m_upgradeItemCostDict) do
        local _, expItemData = expItemDataMap:TryGetValue(itemId)
        local exp = expItemData.expGain
        expSum = expSum + exp * itemCount
    end

    return expSum
end






CharUpgradeCtrl._CalcLevelByExp = HL.Method(HL.Number, HL.Number, HL.Number).Return(HL.Number, HL.Number) << function(self, addExp, curLevel, maxLevel)
    local level2RequireExpDict = self.m_level2RequireExpDict

    local maxExpRequire = level2RequireExpDict[maxLevel] or 0
    if addExp >= maxExpRequire then
        return maxLevel, addExp - maxExpRequire
    end

    for level = maxLevel, curLevel + 1, -1 do
        local requireExp = level2RequireExpDict[level]
        if addExp >= requireExp then
            return level, addExp - requireExp
        end
    end

    return curLevel, addExp
end





CharUpgradeCtrl._RefreshUpgradeItemCell = HL.Method(HL.Table, HL.String) << function(self, cell, itemId)
    local costCount = self.m_upgradeItemCostDict[itemId] or 0
    local inventoryCount = Utils.getItemCount(itemId, true)

    local toggleNumberSelectorKeyHint = function(visible)
        cell.reduceKeyHint.gameObject:SetActive(visible)
        cell.addKeyHint.gameObject:SetActive(visible)
    end

    cell.upgradeItemCell.onIsNaviTargetChanged = function(isTarget, isGroupChanged)
        if isTarget then
            
            if self.m_curNaviTargetUpgradeItemCell ~= cell then
                cell.itemBlack:ShowTips()
                cell.itemBlack:SetSelected(false)
            end

            self.m_curNaviTargetUpgradeItemCell = cell
        end
        toggleNumberSelectorKeyHint(isTarget)
    end

    if DeviceInfo.usingController then
        toggleNumberSelectorKeyHint(cell.upgradeItemCell.isNaviTarget)
    end

    cell.itemBlack:InitItem({
        id = itemId
    }, true, nil, true)
    if DeviceInfo.usingController then
        cell.itemBlack:SetExtraInfo({
            tipsPosType = UIConst.UI_TIPS_POS_TYPE.RightTop,
            tipsPosTransform = self.view.upgradeNode.focusHintTransform,
            isSideTips = true,
        })
    end

    cell.inventoryCount.text = UIUtils.setCountColor(inventoryCount, inventoryCount <= 0)
    cell.numberSelector:InitNumberSelector(costCount, 0, inventoryCount, function(curNumber)
        local curCount = self.m_upgradeItemCostDict[itemId] or 0
        local countDiff = curNumber - curCount

        if countDiff ~= 0 then
            self:AddUpgradeItem(itemId, countDiff)
            self:_RefreshUpgradeNode(self.m_charInfo)
        end
    end)
    if self.m_fromLevel >= self.m_worldLimitLevel then
        cell.numberSelector.view.addButton.interactable = false
        cell.numberSelector.view.reduceButton.interactable = false
    end

    UIUtils.PlayAnimationAndToggleActive(cell.selectedNode, costCount > 0)
end





CharUpgradeCtrl._ShowItemTips = HL.Method(HL.Any, HL.String) << function(self, cell, itemId)
    Notify(MessageConst.SHOW_ITEM_TIPS, {
        transform = cell.itemBigBlack.transform,
        itemId = itemId,
        safeArea = self.view.upgradeNode.itemList,
        moveVirtualMouse = true,
        onClose = function()
            if not DeviceInfo.usingController then
                cell.itemBigBlack:SetSelected(false)
            end
        end
    })
end




CharUpgradeCtrl._AutoFillUpgradeItem = HL.Method(HL.Opt(HL.Number)).Return(HL.Table) << function(self, targetLevel)
    local charInstId = self.m_charInfo.instId
    local costItemTable = {}
    local expCardInfoList = self.m_expCardInfoList
    local curExp = CharInfoUtils.getCharExpInfo(charInstId)

    targetLevel = targetLevel or (self.m_stageLevel > self.m_worldLimitLevel and self.m_worldLimitLevel or self.m_stageLevel)
    local targetLevelExp = self.m_level2RequireExpDict[targetLevel] or 0
    local expRequire = targetLevelExp - curExp
    local expOverflow = 0
    local fillCount = 0
    if expRequire <= 0 then
        return costItemTable
    end

    for i = #expCardInfoList, 1, -1 do
        if expOverflow > 0 then
            local canGenerateExp = 0
            for j = i, 1, -1 do
                canGenerateExp = canGenerateExp + expCardInfoList[j].inventoryCount * expCardInfoList[j].expGain
            end

            if canGenerateExp > expOverflow + expCardInfoList[i + 1].expGain then
                costItemTable[expCardInfoList[i + 1].itemId] = costItemTable[expCardInfoList[i + 1].itemId] - 1
                fillCount, expRequire, expOverflow = self:_TryFillUpgradeItem(expCardInfoList[i].expGain, expCardInfoList[i].inventoryCount, expCardInfoList[i + 1].expGain - expOverflow)
                costItemTable[expCardInfoList[i].itemId] = fillCount
            else
                return costItemTable
            end
        else
            fillCount, expRequire, expOverflow = self:_TryFillUpgradeItem(expCardInfoList[i].expGain, expCardInfoList[i].inventoryCount, expRequire)
            costItemTable[expCardInfoList[i].itemId] = fillCount
        end
    end

    return costItemTable
end









CharUpgradeCtrl._GenerateExpCardInfoList = HL.Method(HL.Number).Return(HL.Table) << function(self, charInstId)
    local expItemDataMap = Tables.expItemDataMap
    local expCardInfoList = {}
    local curExp, levelUpExp, curLevel, maxLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)
    for _, cardItemId in pairs(expCards) do
        local _, expItemData = expItemDataMap:TryGetValue(cardItemId)
        local expGain = expItemData.expGain
        local inventoryCount = Utils.getItemCount(cardItemId, true)

        table.insert(expCardInfoList, {
            itemId = cardItemId,
            expGain = expGain,
            inventoryCount = inventoryCount,
        })
    end
    expCardInfoList = lume.sort(expCardInfoList, function(a, b)
        return a.expGain < b.expGain
    end)
    return expCardInfoList
end






CharUpgradeCtrl._TryFillUpgradeItem = HL.Method(HL.Number, HL.Number, HL.Number).Return(HL.Number, HL.Number, HL.Number) << function(self, expGain, inventoryCount, expRequire)
    local wishCount = math.ceil(expRequire / expGain)
    local costCount = math.min(wishCount, inventoryCount)
    local generateExp = costCount * expGain

    local expLeft = expRequire - generateExp
    local expOverflow = generateExp - expRequire

    return costCount, expLeft, expOverflow
end




CharUpgradeCtrl._RefreshBreakNode = HL.Method(HL.Number) << function(self, charInstId)
    local charInstInfo = CharInfoUtils.getPlayerCharInfoByInstId(charInstId)
    local breakNode = self.view.breakNode
    local curExp, levelUpExp, curLevel, stageLevel = CharInfoUtils.getCharExpInfo(charInstId)

    breakNode.charEliteMarker:InitCharEliteMarker(charInstId)
    breakNode.breakLevelTitle.text = string.format(Language.LUA_CHAR_INFO_BREAK_LEVEL_TITLE, charInstInfo.breakStage)
    breakNode.breakLevelDesc.text = string.format(Language.LUA_CHAR_INFO_BREAK_LEVEL_DESC, curLevel, curLevel)

    breakNode.upgradeLevelNode.addExp.gameObject:SetActive(false)
    breakNode.upgradeLevelNode.addLevel.gameObject:SetActive(false)
    breakNode.upgradeLevelNode.addExp.gameObject:SetActive(false)
    breakNode.upgradeLevelNode.addLevel.gameObject:SetActive(false)
    breakNode.upgradeLevelNode.addExpIcon.gameObject:SetActive(false)
    breakNode.upgradeLevelNode.addLevelIcon.gameObject:SetActive(false)

    breakNode.upgradeLevelNode.curLevel.text = curLevel
    breakNode.upgradeLevelNode.stageLevel.text = stageLevel
    breakNode.upgradeLevelNode.curExp.text = curExp
    breakNode.upgradeLevelNode.nextLvExp.text = curExp


    local isMaxLevel = curLevel >= stageLevel and charInstInfo.breakStage >= Tables.characterConst.maxBreak
    breakNode.breakInfoNode.gameObject:SetActive(not isMaxLevel)
    if not isMaxLevel then
        local breakCfg = Tables.charBreakTable[charInstInfo.breakStage + 1]
        if breakCfg then
            breakNode.breakDesc.text = string.format(Language.LUA_CHAR_INFO_UPGRADE_TO_BREAK_HINT, breakCfg.maxLevel)
        end
    end

    breakNode.weaponAttributeNode:InitCharAttributeNode(charInstId, curLevel, charInstInfo.breakStage, { forceDiff = false })

    self.view.breakNode.btnBreak.gameObject:SetActive(charInstInfo.breakStage < Tables.characterConst.maxBreak)

end




CharUpgradeCtrl._InitUpgradeCache = HL.Method(HL.Table) << function(self, charInfo)
    local charInstId = charInfo.instId
    local curExp, levelUpExp, curLevel, maxLevel, expCards = CharInfoUtils.getCharExpInfo(charInstId)
    local levelUpData = Tables.charLevelUpTable

    local startExp = levelUpData[curLevel].exp
    local startGold = levelUpData[curLevel].gold

    local level2RequireExpDict = {}
    local level2RequireGoldDict = {}
    for levelIndex = curLevel + 1, maxLevel do
        level2RequireExpDict[levelIndex] = startExp
        level2RequireGoldDict[levelIndex] = startGold
        startExp = startExp + levelUpData[levelIndex].exp
        startGold = startGold + levelUpData[levelIndex].gold
    end

    self.m_upgradeItemCostDict = {}
    self.m_level2RequireGoldDict = level2RequireGoldDict
    self.m_level2RequireExpDict = level2RequireExpDict
    self.m_expCardInfoList = self:_GenerateExpCardInfoList(charInstId)
end



CharUpgradeCtrl._InitActionEvent = HL.Method() << function(self)
    self.m_upgradeItemCellCache = UIUtils.genCellCache(self.view.upgradeNode.upgradeItemCell)

    self.view.upgradeNode.btnReset.onClick:AddListener(function()
        self.m_upgradeItemCostDict = {}
        self:_RefreshUpgradeNode(self.m_charInfo)

    end)
    self.view.upgradeNode.btnAutoFill.onClick:AddListener(function()
        self.m_upgradeItemCostDict = self:_AutoFillUpgradeItem()
        self:_RefreshUpgradeNode(self.m_charInfo)
    end)

    self.view.btnBack.onClick:AddListener(function()
        self:Notify(MessageConst.CHAR_INFO_PAGE_CHANGE, {
            pageType = UIConst.CHAR_INFO_PAGE_TYPE.OVERVIEW
        })
    end)

    self.view.upgradeNode.btnLevelUp.onClick:AddListener(function()
        if not self:_CheckHasUpgradeItem() then
            self:Notify(MessageConst.SHOW_TOAST, Language.LUA_CHAR_UPGRADE_NONE_ITEM)
            return
        end

        if not self:_CheckGoldEnough() then
            self:Notify(MessageConst.SHOW_TOAST, Language.LUA_NOT_ENOUGH_GOLD)
            return
        end
        GameInstance.player.charBag:CharLevelUp(self.m_charInfo.instId, self.m_upgradeItemCostDict)
    end)

    self.view.breakNode.btnBreak.onClick:AddListener(function()
        self:Notify(MessageConst.CHAR_INFO_PAGE_CHANGE, {
            pageType = UIConst.CHAR_INFO_PAGE_TYPE.TALENT,
            isFast = true,
            showGlitch = true,
            extraArg = {
                showNextCharBreak = true,
            }
        })
    end)

    self.view.upgradeNode.upgradeListSelectableNaviGroup.onIsFocusedChange:AddListener(function(isFocused)
        if not isFocused then
            self.m_curNaviTargetUpgradeItemCell = nil

            
            Notify(MessageConst.HIDE_ITEM_TIPS)
        end
    end)

    self.view.upgradeNode.addBtn.onClick:AddListener(function()
        self.m_upgradeItemCostDict = self:_AutoFillUpgradeItem(self.m_toLevel + 1)
        self:_RefreshUpgradeNode(self.m_charInfo)
    end)
    self.view.upgradeNode.subBtn.onClick:AddListener(function()
        local curExp, _, curLevel, stageLevel = CharInfoUtils.getCharExpInfo(self.m_charInfo.instId)
        local targetLevel
        local tryLevel = self.m_toLevel
        repeat
            tryLevel = tryLevel - 1
            self.m_upgradeItemCostDict = self:_AutoFillUpgradeItem(tryLevel)
            local curGenerateExp = self:_GetCurAddOnExp()
            local curAddExp = curGenerateExp + curExp
            targetLevel = self:_CalcLevelByExp(curAddExp, curLevel, stageLevel)
        until targetLevel <= tryLevel or tryLevel == 0

        self:_RefreshUpgradeNode(self.m_charInfo)
    end)
    self.view.upgradeNode.upgradeTips.tipsBtn.onClick:AddListener(function()
        UIManager:AutoOpen(PanelId.WorldLevelTipsPopup, { isTipsMode = true })
    end)
end



CharUpgradeCtrl._CheckGoldEnough = HL.Method().Return(HL.Boolean) << function(self)
    local needGold = self.m_level2RequireGoldDict[self.m_toLevel] or 0
    local curGold = Utils.getItemCount(UIConst.INVENTORY_MONEY_IDS[1], true)

    return curGold >= needGold
end



CharUpgradeCtrl._CheckHasUpgradeItem = HL.Method().Return(HL.Boolean) << function(self)
    if not self.m_upgradeItemCostDict then
        return false
    end

    local hasItem = false
    for i, costCount in pairs(self.m_upgradeItemCostDict) do
        if costCount > 0 then
            hasItem = true
            break
        end
    end

    return hasItem
end



CharUpgradeCtrl._CanAddItem = HL.Method().Return(HL.Boolean) << function(self)
    for _, info in ipairs(self.m_expCardInfoList) do
        local costCount = self.m_upgradeItemCostDict[info.itemId] or 0
        if costCount < info.inventoryCount then
            return true
        end
    end
    return false
end





CharUpgradeCtrl._UpdateAddAndSubBtnState = HL.Method() << function(self)
    self.view.upgradeNode.subBtnStateController:SetState(
        (self.m_toLevel > self.m_fromLevel and self.m_fromLevel < self.m_worldLimitLevel) and "normal" or "gray")
    self.view.upgradeNode.addBtnStateController:SetState(
        (self.m_toLevel < self.m_stageLevel and self:_CanAddItem() and self.m_toLevel < self.m_worldLimitLevel) and "normal" or "gray")
end



HL.Commit(CharUpgradeCtrl)