local uiCtrl = require_ex('UI/Panels/Base/UICtrl')

local INSTRUCTION_ID = "spaceship_gift_send"
local FRIENDSHIP_PRESENT_GIFT_SORT_OPTION = {
    {
        
        name = Language.LUA_GIFT_SORT_DEFAULT,
        keys = { "isLike", "isAvailable", "isPreferTagMatch", "count", "sortId1Reverse" },
        reverseKeys = {"isLikeReverse", "isAvailableReverse", "isPreferTagMatch", "count", "sortId1Reverse" },
    },
    {
        
        name = Language.LUA_GIFT_SORT_PREFER_TAG_MATCH,
        keys = { "isLike", "isPreferTagMatch",  "isAvailable", "count", "sortId1Reverse" },
        reverseKeys = { "isLikeReverse", "isPreferTagMatch", "isAvailableReverse", "count", "sortId1Reverse" },
    },
    {
        
        name = Language.LUA_GIFT_SORT_COUNT,
        keys = { "isLike", "count", "isAvailable", "isPreferTagMatch", "sortId1Reverse" },
        reverseKeys = { "isLikeReverse", "count", "isAvailableReverse", "isPreferTagMatch", "sortId1Reverse" },
    },
}


























































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


FriendShipPresentCtrl.m_charId = HL.Field(HL.String) << ""


FriendShipPresentCtrl.m_level = HL.Field(HL.Number) << 1


FriendShipPresentCtrl.m_charTagData = HL.Field(HL.Userdata)


FriendShipPresentCtrl.m_gifts = HL.Field(HL.Table)


FriendShipPresentCtrl.m_filteredGifts = HL.Field(HL.Table)


FriendShipPresentCtrl.m_sentGifts = HL.Field(HL.Table)


FriendShipPresentCtrl.m_selected = HL.Field(HL.Table)


FriendShipPresentCtrl.m_curSelectedNum = HL.Field(HL.Number) << 0


FriendShipPresentCtrl.m_curSelectedIncrease = HL.Field(HL.Number) << 0


FriendShipPresentCtrl.m_curIncreaseInfo = HL.Field(HL.Table)


FriendShipPresentCtrl.m_getGiftItemCell = HL.Field(HL.Function)


FriendShipPresentCtrl.m_getSentGiftItemCell = HL.Field(HL.Function)


FriendShipPresentCtrl.m_itemTagCellCache = HL.Field(HL.Forward("UIListCache"))


FriendShipPresentCtrl.m_charTagCellCache = HL.Field(HL.Forward("UIListCache"))


FriendShipPresentCtrl.m_successCor = HL.Field(HL.Thread)


FriendShipPresentCtrl.s_sortInfo = HL.StaticField(HL.Table) << {}


FriendShipPresentCtrl.m_selectedFilterTags = HL.Field(HL.Table)




FriendShipPresentCtrl.m_decreaseButtonBindingId = HL.Field(HL.Number) << -1


FriendShipPresentCtrl.m_focusItemId = HL.Field(HL.String) << ""


FriendShipPresentCtrl.m_focusLuaIndex = HL.Field(HL.Number) << -1







FriendShipPresentCtrl.s_messages = HL.StaticField(HL.Table) << {
    [MessageConst.ON_VALUABLE_DEPOT_CHANGED] = '_OnItemRefresh',
    [MessageConst.ON_CHAR_FRIENDSHIP_CHANGED] = '_OnCharPresentRefresh',
    [MessageConst.ON_CHAR_FRIENDSHIP_SEND_CHAR_GIFT_SUCCESS] = '_OnCharSendPresentSuccess',
}




FriendShipPresentCtrl._OnItemRefresh = HL.Method(HL.Table) << function(self, _)
    
    self:_RefreshGiftList()
end



FriendShipPresentCtrl._OnCharPresentRefresh = HL.Method() << function(self)
    self:_RefreshFriendshipInfo()
end




FriendShipPresentCtrl._OnCharSendPresentSuccess = HL.Method(HL.Table) << function(self, data)
    self:PlayAnimationOutWithCallback(function()
        local level = CSPlayerDataUtil.GetFriendshipLevelByChar(self.m_charId)
        local deltaFav = unpack(data)
        self:Notify(MessageConst.DIALOG_SEND_PRESENT_END, {
            success = true,
            nextIndex = 0,
            deltaFav = deltaFav,
            selectedItems = self.m_selected,
            levelChanged = level ~= self.m_level
        })
        self.m_level = level
    end)
end





FriendShipPresentCtrl.OnCreate = HL.Override(HL.Any) << function(self, arg)
    self.m_charId = arg.charId
    self.m_level = CSPlayerDataUtil.GetFriendshipLevelByChar(self.m_charId)
    self.m_charTagData = Tables.characterTagTable:GetValue(self.m_charId)
    self.m_gifts = {}
    self.m_filteredGifts = {}
    self.m_sentGifts = {}
    self.m_selected = {}
    self.m_curIncreaseInfo = {}

    
    self.view.titleTxt.text = Language.LUA_GIFT_SEND_TITLE

    self.view.helpBtn.onClick:AddListener(function()
        UIManager:Open(PanelId.InstructionBook, INSTRUCTION_ID)
    end)

    
    self:InitFriendshipNode()

    
    self.m_getGiftItemCell = UIUtils.genCachedCellFunction(self.view.bottomList.scrollList)
    self.view.bottomList.scrollList.onUpdateCell:AddListener(function(object, index)
        self:_RefreshGiftItemCell(object, LuaIndex(index))
    end)

    self.m_getSentGiftItemCell = UIUtils.genCachedCellFunction(self.view.bottomList.sentGiftScrollList)
    self.view.bottomList.sentGiftScrollList.onUpdateCell:AddListener(function(object, index)
        self:_RefreshSentGiftItemCell(object, LuaIndex(index))
    end)

    
    self.view.closeBtn.onClick:AddListener(function()
        self:PlayAnimationOutWithCallback(function()
            self:Notify(MessageConst.DIALOG_SEND_PRESENT_END, {
                success = false,
                nextIndex = 1,
            })
        end)
    end)

    
    self.view.main.onClick:AddListener(function()
        self:_RefreshTips(false)
    end)

    self.view.bottomList.buttonClear.onClick:AddListener(function()
        self:_ClearSelected()
    end)

    
    self.view.bottomList.buttonSend.onClick:AddListener(function()
        self:_SendPresentToChar()
    end)

    
    self:InitFilterButton()

    
    self.view.sortNode:InitSortNode(FRIENDSHIP_PRESENT_GIFT_SORT_OPTION, function(optData, isIncremental)
        self:_OnSortChanged(optData, isIncremental)
    end, 0, false, false, self.view.filterBtn)

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





FriendShipPresentCtrl.InitFilterButton = HL.Method() << function(self)
    local hobbyFilterTag = {
        name = Language.LUA_GIFT_HOBBY_TAG_MATCH,
        filterWithHobbyTag = true,
    }

    local preferFilterTag = {
        name = Language.LUA_GIFT_PREFER_TAG_MATCH,
        filterWithPreferTag = true,
    }

    local defaultSelectedTags = {}
    self.m_selectedFilterTags = defaultSelectedTags

    local filterConfig = {
        tagGroups = {
            {tags = {hobbyFilterTag, preferFilterTag},}
        },
        selectedTags = defaultSelectedTags,
        onConfirm = function(selectedTags) self:OnFilterChanged(selectedTags) end,
        getResultCount = function(selectedTags) return self:GetFilterResultCount(selectedTags) end,
        sortNodeWidget = self.view.sortNode,
    }

    self.view.filterBtn:InitFilterBtn(filterConfig)
end




FriendShipPresentCtrl.OnFilterChanged = HL.Method(HL.Table) << function(self, selectedTags)
    self.m_selectedFilterTags = selectedTags
    local filteredGifts = self:GetFilterResult(self.m_selectedFilterTags, true)

    
    local isChanged = false
    if #filteredGifts ~= #self.m_filteredGifts then
        isChanged = true
    else
        for i, v in ipairs(filteredGifts) do
            if v ~= self.m_filteredGifts[i] then
                isChanged = true
                break
            end
        end
    end

    if isChanged then
        self.m_filteredGifts = filteredGifts
        self.view.sortNode:SortCurData()
    end
end




FriendShipPresentCtrl.GetFilterResultCount = HL.Method(HL.Table).Return(HL.Number) << function(self, selectedTags)
    return #self:GetFilterResult(selectedTags)
end





FriendShipPresentCtrl.GetFilterResult = HL.Method(HL.Table, HL.Opt(HL.Boolean)).Return(HL.Table) << function(self, selectedTags, withSelected)
    if selectedTags == nil or #selectedTags == 0 then
        
        return self.m_gifts
    end

    local filterResult = {}
    for _, gift in ipairs(self.m_gifts) do
        if withSelected and self.m_selected[gift.itemId] and self.m_selected[gift.itemId] > 0 then
            table.insert(filterResult, gift)
            goto continue
        end

        local isLike = gift.isLike == 1
        local isPreferTagMatch = gift.isPreferTagMatch == 1
        local isMatched = true
        for _, tag in ipairs(selectedTags) do
            if tag.filterWithHobbyTag and not isLike then
                isMatched = false
                break
            end

            if tag.filterWithPreferTag and not isPreferTagMatch then
                isMatched = false
                break
            end
        end

        if isMatched then
            table.insert(filterResult, gift)
        end

        ::continue::
    end
    return filterResult
end






FriendShipPresentCtrl.OnShow = HL.Override() << function(self)
    self:_RefreshCharInfo()
    self:_RefreshFriendshipInfo(true)
    self:_RefreshGiftList()
    self:_RefreshButtonState()
end



FriendShipPresentCtrl._RefreshCharInfo = HL.Method() << function(self)
    local charId = self.m_charId
    if charId == nil or charId == "" then
        return
    end

    local charInfoNode = self.view.rightTrustNode.charInfoNode
    if self.m_charTagCellCache == nil then
        self.m_charTagCellCache = UIUtils.genCellCache(charInfoNode.tagNode.tagCell)
    end

    local charName = Tables.characterTable[charId].name
    local charHobbyTags = self.m_charTagData.hobbyTagIds

    local charGiftPreferTag = self.m_charTagData.giftPreferTagId

    charInfoNode.name.text = charName
    charInfoNode.headIcon:LoadSprite(UIConst.UI_SPRITE_CHAR_REMOTE_ICON, UIConst.UI_CHAR_REMOTE_ICON_PREFIX .. charId)

    self.m_charTagCellCache:Refresh(charHobbyTags.Count, function(cell, index)
        local tagId = charHobbyTags[CSIndex(index)]
        local tagName = Tables.tagDataTable[tagId].tagName
        cell.nameTxt.text = tagName;
        cell.stateController:SetState("Normal")
    end)

    if charGiftPreferTag.Count > 0 then
        
        local preferTagId = charGiftPreferTag[CSIndex(1)]
        local preferTagName = Tables.tagDataTable[preferTagId].tagName
        charInfoNode.areaName.text = preferTagName

        local preferTagIcon = self:_GetPreferTagIcon(preferTagId)
        if preferTagIcon and preferTagIcon ~= "" then
            charInfoNode.areaIcon:LoadSprite(UIConst.UI_SPRITE_SHIP, preferTagIcon)
        end
    end
end



FriendShipPresentCtrl.InitFriendshipNode = HL.Method() << function(self)
    local rightTrustNode = self.view.rightTrustNode
    local giftGainRatioLevels = Tables.spaceshipCharGiftGainRatio

    rightTrustNode.bigSmiley:InitCircularProgressBar(giftGainRatioLevels[1].maxLimit)
    rightTrustNode.midSmiley:InitCircularProgressBar(giftGainRatioLevels[2].maxLimit - giftGainRatioLevels[1].maxLimit)
    rightTrustNode.smallSmiley:InitCircularProgressBar(giftGainRatioLevels[3].maxLimit - giftGainRatioLevels[2].maxLimit)
end




FriendShipPresentCtrl._RefreshFriendshipInfo = HL.Method(HL.Opt(HL.Boolean)) << function(self, isInit)
    isInit = isInit or false
    if self:_IsMax() then
        self.view.mainStateController:SetState("Max")
        self.view.reliabilityCell:InitReliabilityCell(self.m_charId)
        self.view.reliabilityCell:RefreshTmpFriendship(0)
        self:_RefreshSentGifts()
        return
    end

    self.view.mainStateController:SetState("Normal")
    local rightTrustNode = self.view.rightTrustNode
    local giftGainRatioLevels = Tables.spaceshipCharGiftGainRatio

    local percent, showPercent = self:_GetCurFriendshipPercent()
    local charTrustNode = rightTrustNode.charInfoNode.charTrustNode

    if self.m_curSelectedIncrease > 0 then
        local tmpPercent, tmpShowPercent = self:_GetCurFriendshipPercent(self.m_curSelectedIncrease)
        charTrustNode.circleTmpStart.fillAmount = lume.clamp(tmpShowPercent / 100, 0, 1);
        charTrustNode.circleCur.fillAmount = lume.clamp(showPercent / 100, 0, 1);
        charTrustNode.trustNumTxt.text = string.format("%d%%", tmpPercent)
        if charTrustNode.stateController.currentStateName ~= "High" then
            charTrustNode.stateController:SetState("High")
            charTrustNode.animationWrapper:PlayInAnimation()
        end
    else
        charTrustNode.circleCur.fillAmount = lume.clamp(showPercent / 100, 0, 1);
        charTrustNode.circleTmpStart.fillAmount = 0;
        charTrustNode.trustNumTxt.text = string.format("%d%%", percent)
        if charTrustNode.stateController.currentStateName ~= "Normal" then
            charTrustNode.stateController:SetState("Normal")
            charTrustNode.animationWrapper:PlayOutAnimation()
        end
    end

    local dailyFriendshipIncrease = CSPlayerDataUtil.GetCharDailyFriendshipIncrease(self.m_charId)
    local dailyFriendshipGainRatioLevel = CSPlayerDataUtil.GetGiftGainRatioLevelByChar(self.m_charId, self.m_curSelectedIncrease)

    local sendTips = Language.LUA_GIFT_SEND_TIPS_LIMIT_LV1
    if self:_IsTodayMax() then
        rightTrustNode.stateController:SetState("SentOut")
        
        rightTrustNode.bigSmiley:SetCurrentValue(dailyFriendshipIncrease)
        sendTips = Language.LUA_GIFT_SEND_TIPS_LIMIT_MAX
    else
        if dailyFriendshipGainRatioLevel == 1 then
            rightTrustNode.stateController:SetState("HighTrust", false)
            sendTips = Language.LUA_GIFT_SEND_TIPS_LIMIT_LV1
        elseif dailyFriendshipGainRatioLevel == 2 then
            rightTrustNode.stateController:SetState("MiddleTrust", false)
            sendTips = Language.LUA_GIFT_SEND_TIPS_LIMIT_LV2
        elseif dailyFriendshipGainRatioLevel == 3 then
            rightTrustNode.stateController:SetState("LowTrust", false)
            sendTips = Language.LUA_GIFT_SEND_TIPS_LIMIT_LV3
        end

        if isInit then
            
            
            rightTrustNode.bigSmiley:SetCurrentValue(dailyFriendshipIncrease)
            rightTrustNode.midSmiley:SetCurrentValue(dailyFriendshipIncrease - giftGainRatioLevels[1].maxLimit)
            rightTrustNode.smallSmiley:SetCurrentValue(dailyFriendshipIncrease - giftGainRatioLevels[2].maxLimit)
        end

        
        rightTrustNode.bigSmiley:SetTempValue(self.m_curIncreaseInfo[1] or 0)
        rightTrustNode.midSmiley:SetTempValue(self.m_curIncreaseInfo[2] or 0)
        rightTrustNode.smallSmiley:SetTempValue(self.m_curIncreaseInfo[3] or 0)
    end

    rightTrustNode.sendText.text = sendTips
end




FriendShipPresentCtrl._GetCharLike = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    local giftData = Tables.giftItemTable:GetValue(itemId)
    local tagList = giftData.tagList
    local charTagData = self.m_charTagData
    local hobbyTagIds = charTagData.hobbyTagIds
    local like = false
    for _, tag in pairs(tagList) do
        if lume.find(hobbyTagIds, tag) then
            like = true
            break
        end
    end
    return like
end




FriendShipPresentCtrl._GetCharPreferTagMatch = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    local giftData = Tables.giftItemTable:GetValue(itemId)
    local giftPreferTag = giftData.giftPreferTag
    local charTagData = self.m_charTagData
    local charPreferTags = charTagData.giftPreferTagId
    return lume.find(charPreferTags, giftPreferTag) ~= nil
end



FriendShipPresentCtrl._RefreshSentGifts = HL.Method() << function(self)
    self.m_sentGifts = {}
    local sentGifts = CSPlayerDataUtil.GetCharSentGifts(self.m_charId)
    local list = Tables.itemListByTypeTable:GetValue(GEnums.ItemType.Gift).list
    for _, itemId in pairs(list) do
        local success, giftData = Tables.giftItemTable:TryGetValue(itemId)
        if not success or giftData.giftPreferTag == nil or giftData.giftPreferTag == "" then
            
            goto continue
        end

        local isLike = self:_GetCharLike(itemId)
        if not isLike then
            goto continue
        end

        local res, sentCount = sentGifts:TryGetValue(itemId)
        if not res then
            sentCount = 0
        end

        local isPreferTagMatch = self:_GetCharPreferTagMatch(itemId)
        local data = {
            itemId = itemId,
            isPreferTagMatch = isPreferTagMatch and 1 or 0,
            sentCount = sentCount,
        }

        table.insert(self.m_sentGifts, data)
        ::continue::
    end

    table.sort(self.m_sentGifts, Utils.genSortFunction({"sentCount", "isPreferTagMatch"}, false))

    self.view.bottomList.sentGiftScrollList:UpdateCount(#self.m_sentGifts)
    self.view.sentGiftNaviGroup:NaviToThisGroup(true)
end



FriendShipPresentCtrl._RefreshGiftList = HL.Method() << function(self)
    if self:_IsMax() then
        self.view.giftRecordTitle.text = Language.LUA_GIFT_RECORD_TITLE
        
        return
    end

    self.m_gifts = {}
    local list = Tables.itemListByTypeTable:GetValue(GEnums.ItemType.Gift).list
    for _, itemId in pairs(list) do
        local success, giftData = Tables.giftItemTable:TryGetValue(itemId)
        if not success or giftData.giftPreferTag == nil or giftData.giftPreferTag == "" then
            
            goto continue
        end

        local count = Utils.getItemCount(itemId)
        local favorablePoint = giftData.favorablePoint
        local isLike = self:_GetCharLike(itemId)
        local isPreferTagMatch = self:_GetCharPreferTagMatch(itemId)
        local itemData = Tables.itemTable:GetValue(itemId)
        local isAvailable = count > 0 and isLike
        local data = {
            itemId = itemId,
            count = count,
            countReverse = -count,
            isLike = isLike and 1 or 0,
            isLikeReverse = isLike and 0 or 1,
            isAvailable = isAvailable and 1 or 0,
            isAvailableReverse = isAvailable and 0 or 1,
            isPreferTagMatch = isPreferTagMatch and 1 or 0,
            favorablePoint = favorablePoint,
            rarity = itemData.rarity,
            sortId1Reverse = -itemData.sortId1,
        }
        table.insert(self.m_gifts, data)
        ::continue::
    end

    self:OnFilterChanged(self.m_selectedFilterTags)
end





FriendShipPresentCtrl._GetCurFriendshipPercent = HL.Method(HL.Opt(HL.Number)).Return(HL.Number, HL.Number) << function(self, tmpValue)
    tmpValue = tmpValue or 0
    local curLevel = CSPlayerDataUtil.GetFriendshipLevelByChar(self.m_charId)
    local maxLevel = CSPlayerDataUtil.maxFriendshipLevel

    local showPercent = 0
    local percent = 0

    if curLevel ~= maxLevel then
        local lastFriendShip

        if curLevel == 1 then
            lastFriendShip = 0
        else
            lastFriendShip = CSPlayerDataUtil.favoriteLevelMap[curLevel - 1]
        end
        local curFriendShip = CSPlayerDataUtil.GetCharFriendship(self.m_charId) + tmpValue
        local needFriendShip = CSPlayerDataUtil.favoriteLevelMap[curLevel]

        showPercent = math.floor((curFriendShip - lastFriendShip) * 100 / needFriendShip)
        percent = CharInfoUtils.getCharRelationShowValue(curFriendShip)
    end

    return percent, showPercent
end





FriendShipPresentCtrl._IsMax = HL.Method(HL.Opt(HL.Number)).Return(HL.Boolean) << function(self, tmpNum)
    local isMax
    if tmpNum then
        local friendshipValue = CSPlayerDataUtil.GetCharFriendship(self.m_charId)
        local tmpValue = friendshipValue + tmpNum
        isMax = tmpValue >= CSPlayerDataUtil.maxFriendship
    else
        local level = CSPlayerDataUtil.GetFriendshipLevelByChar(self.m_charId)
        local maxLevel = CSPlayerDataUtil.maxFriendshipLevel
        isMax = level == maxLevel
    end

    return isMax
end



FriendShipPresentCtrl._IsTodayMax = HL.Method().Return(HL.Boolean) << function(self)
    local friendShipIncreaseRemain = CSPlayerDataUtil.GetCharDailyRemainFriendshipIncrease(self.m_charId)
    return friendShipIncreaseRemain <= 0
end






FriendShipPresentCtrl._OnSortChanged = HL.Method(HL.Table, HL.Boolean) << function(self, optData, isIncremental)
    local keys =  isIncremental and optData.reverseKeys or optData.keys
    table.sort(self.m_filteredGifts, Utils.genSortFunction(keys, isIncremental))
    self.view.bottomList.scrollList:UpdateCount(#self.m_filteredGifts)
    self.view.normalNaviGroup:NaviToThisGroup(true)
end




FriendShipPresentCtrl._GetPreferTagIcon = HL.Method(HL.String).Return(HL.String) << function(self, preferTagId)
    local success, data = Tables.giftPreferTagConfigTable:TryGetValue(preferTagId)
    if success then
        return data.iconName
    else
        return ""
    end
end





FriendShipPresentCtrl._RefreshGiftItemCell = HL.Method(HL.Userdata, HL.Number) << function(self, object, luaIndex)
    local itemId = self.m_filteredGifts[luaIndex].itemId
    local giftData = Tables.giftItemTable:GetValue(itemId)
    local count = Utils.getItemCount(itemId)
    local cell = self.m_getGiftItemCell(object)
    local data = {
        id = itemId,
        count = count
    }

    local itemCell = cell.listCellFriendshipUpgrade

    itemCell.item:SetEnableHoverTips(false)
    itemCell.item:InitItem(data, function()
        self:_OnItemSelectClicked(itemId, luaIndex)
    end)

    itemCell.item.view.button.onIsNaviTargetChanged = function(isNaviTarget)
        if isNaviTarget then
           self:_OnItemFocused(itemId, luaIndex)
        end
    end

    local preferTagId = giftData.giftPreferTag
    local iconName = self:_GetPreferTagIcon(preferTagId)
    if iconName and iconName ~= "" then
        itemCell.areaIcon.gameObject:SetActive(true)
        itemCell.areaIcon:LoadSprite(UIConst.UI_SPRITE_SHIP, iconName)
    end

    
    local isLike = self:_GetCharLike(itemId)
    if isLike then
        itemCell.unableGift.gameObject:SetActive(false)
    else
        itemCell.unableGift.gameObject:SetActive(true)
    end

    
    self:_RefreshSingleItemSelect(itemCell)

    itemCell.btnMinus.onClick:RemoveAllListeners()
    itemCell.btnMinus.onClick:AddListener(function()
        self:_OnItemMinusClicked(itemId, luaIndex)
    end)
end





FriendShipPresentCtrl._RefreshSentGiftItemCell = HL.Method(HL.Userdata, HL.Number) << function(self, object, luaIndex)
    local itemId = self.m_sentGifts[luaIndex].itemId
    local sentCount = self.m_sentGifts[luaIndex].sentCount
    local giftData = Tables.giftItemTable:GetValue(itemId)
    local cell = self.m_getGiftItemCell(object)
    local data = {
        id = itemId,
    }

    local itemCell = cell.listCellFriendshipUpgrade

    itemCell.item:SetEnableHoverTips(false)
    itemCell.item:InitItem(data, function()
        self:_RefreshTips(true, itemId)
    end)

    local preferTagId = giftData.giftPreferTag
    local iconName = self:_GetPreferTagIcon(preferTagId)
    if iconName and iconName ~= "" then
        itemCell.areaIcon.gameObject:SetActive(true)
        itemCell.areaIcon:LoadSprite(UIConst.UI_SPRITE_SHIP, iconName)
    end

    
    if sentCount == 0 then
        itemCell.item:SetIconTransparent(UIConst.ITEM_MISSING_TRANSPARENCY)
    else
        itemCell.item:SetIconTransparent(UIConst.ITEM_EXIST_TRANSPARENCY)
    end

    itemCell.sentCountTxt.text = string.format(Language.LUA_GIFT_SENT_COUNT, sentCount)
end






FriendShipPresentCtrl._OnItemFocused = HL.Method(HL.String, HL.Number) << function(self, itemId, luaIndex)
    if not DeviceInfo.usingController then
        return
    end

    if self:_IsMax() then
        self:_RefreshTips(true, itemId)
        return
    end

    self.m_focusItemId = itemId
    self.m_focusLuaIndex = luaIndex

    self:_RefreshInputKeyHint(itemId, luaIndex)
    self:_RefreshTips(true, itemId)
end





FriendShipPresentCtrl._RefreshInputKeyHint = HL.Method(HL.String, HL.Number) << function(self, itemId, luaIndex)
    if not DeviceInfo.usingController then
        return
    end

    if itemId == "" or luaIndex < 0 then
        return
    end

    local selectNum = self.m_selected[itemId] or 0
    local cell = self:_GetCellByIndex(luaIndex)
    if not cell then
        return
    end

    if self.m_decreaseButtonBindingId < 0 then
        self.m_decreaseButtonBindingId = self:BindInputPlayerAction("gift_send_decrease_item_count", function()
            self:_OnItemMinusClicked(self.m_focusItemId, self.m_focusLuaIndex)
        end)

        InputManagerInst:SetBindingText(self.m_decreaseButtonBindingId, Language.LUA_GIFT_COUNT_DECREASE)
    end

    local itemCell = cell.listCellFriendshipUpgrade
    if selectNum > 0 then
        InputManagerInst:SetBindingText(itemCell.item.view.button.hoverConfirmBindingId, Language.LUA_GIFT_COUNT_ADD)
        InputManagerInst:ToggleBinding(self.m_decreaseButtonBindingId, true)
    else
        InputManagerInst:SetBindingText(itemCell.item.view.button.hoverConfirmBindingId, Language.LUA_GIFT_SELECT_ITEM)
        InputManagerInst:ToggleBinding(self.m_decreaseButtonBindingId, false)
    end
end





FriendShipPresentCtrl._OnItemSelectClicked = HL.Method(HL.String, HL.Number) << function(self, itemId, luaIndex)
    local count = Utils.getItemCount(itemId)
    local selectNum = self.m_selected[itemId] or 0
    local tmpSelectNum = selectNum + 1

    if not DeviceInfo.usingController then
        self:_RefreshTips(true, itemId)
    end

    local isMax = self:_IsMax()
    if isMax then
        self:_SelectOnlyOneCell(luaIndex)
        return
    end

    
    local friendShipIncreaseRemain = CSPlayerDataUtil.GetCharDailyRemainFriendshipIncrease(self.m_charId)
    if friendShipIncreaseRemain <= 0 then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_GIFT_DAILY_FRIENDSHIP_INCREASE_LIMITED)
        self:_SelectOnlyOneCell(luaIndex)
        return
    end

    
    local isLike = self:_GetCharLike(itemId)
    if not isLike then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_GIFT_HOBBY_TAG_NOT_MATCH)
        return
    end

    
    if count == 0 then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_GIFT_ITEM_NOT_ENOUGH)
        return
    end

    
    if count < tmpSelectNum then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_SPACESHIP_GIFT_EMPTY)
        return
    end

    if friendShipIncreaseRemain == 0 or self.m_curSelectedIncrease >= friendShipIncreaseRemain then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_GIFT_DAILY_FRIENDSHIP_INCREASE_LIMITED)
        return
    end

    if self:_IsMax(self.m_curSelectedIncrease) then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_SPACESHIP_CHAR_FRIENDSHIP_FULL)
        return
    end

    self.m_selected[itemId] = tmpSelectNum

    local cell = self:_GetCellByIndex(luaIndex)
    if cell then
        self:_RefreshSingleItemSelect(cell.listCellFriendshipUpgrade)
    end

    self:_RefreshSelectedFriendshipIncrease()
    self:_RefreshButtonState()
end




FriendShipPresentCtrl._RefreshSelectedFriendshipIncrease = HL.Method() << function(self)
    local realFriendshipIncrease = 0
    local friendshipIncreaseInfo = {}
    local totalSelectCount = 0

    local sortedGifts = {}
    local keys = lume.keys(self.m_selected)
    table.sort(keys)

    for _, giftId in ipairs(keys) do
        local num = self.m_selected[giftId]
        if num > 0 then
            totalSelectCount = totalSelectCount + num
            local giftData = Tables.giftItemTable:GetValue(giftId)
            local isPreferTagMatch = self:_GetCharPreferTagMatch(giftId)
            local ratio = (not isPreferTagMatch) and Tables.spaceshipConst.notMatchDomainGiftRatio or 1
            table.insert(sortedGifts, {
                itemId = giftId,
                num = self.m_selected[giftId],
                point = lume.round(giftData.favorablePoint * ratio),
            })
        end
    end

    local dailyFriendshipIncrease = CSPlayerDataUtil.GetCharDailyFriendshipIncrease(self.m_charId)
    local giftGainRatioLevel = CSPlayerDataUtil.GetGiftGainRatioLevelByChar(self.m_charId)

    local dailyFriendshipIncreaseMaxLevel = CSPlayerDataUtil.dailyFriendshipIncreaseMaxLevel
    if giftGainRatioLevel > 0 and giftGainRatioLevel <= dailyFriendshipIncreaseMaxLevel then
        
        local giftLeftPoint = 0
        for i = giftGainRatioLevel, dailyFriendshipIncreaseMaxLevel do
            if #sortedGifts <= 0 and giftLeftPoint == 0 then
                break
            end

            local levelData = Tables.spaceshipCharGiftGainRatio[i]
            local levelRealRemain = levelData.maxLimit - dailyFriendshipIncrease
            local levelRealIncrease = 0
            local levelTotalRemain = levelRealRemain / levelData.gainRatio

            while((#sortedGifts > 0 or giftLeftPoint > 0) and levelTotalRemain > 0) do
                local point = giftLeftPoint

                if #sortedGifts > 0 then
                    local gift = sortedGifts[1]
                    gift.num = gift.num - 1
                    if gift.num <= 0 then
                        table.remove(sortedGifts, 1)
                    end
                    point = point + gift.point
                end

                giftLeftPoint = 0

                if point >= levelTotalRemain then
                    levelRealIncrease = levelRealIncrease + levelRealRemain
                    giftLeftPoint = point - levelTotalRemain
                    levelRealRemain = 0
                    levelTotalRemain = 0
                else
                    local giftRealIncrease =  lume.round(point * levelData.gainRatio)
                    levelRealIncrease = levelRealIncrease + giftRealIncrease
                    levelRealRemain = levelRealRemain - giftRealIncrease
                    levelTotalRemain = levelRealRemain / levelData.gainRatio
                end
            end

            realFriendshipIncrease = realFriendshipIncrease + levelRealIncrease
            dailyFriendshipIncrease = dailyFriendshipIncrease + levelRealIncrease
            friendshipIncreaseInfo[i] = levelRealIncrease
        end
    end

    self.m_curSelectedIncrease = realFriendshipIncrease
    self.m_curIncreaseInfo = friendshipIncreaseInfo
    self.m_curSelectedNum = totalSelectCount

    self:_RefreshFriendshipInfo()
end





FriendShipPresentCtrl._OnItemMinusClicked = HL.Method(HL.String, HL.Number) << function(self, itemId, luaIndex)
    local isMax = self:_IsMax()
    if isMax then
        return
    end

    local selectNum = self.m_selected[itemId]
    if selectNum and selectNum > 0 then
        self.m_selected[itemId] = self.m_selected[itemId] - 1
        self.m_curSelectedNum = self.m_curSelectedNum - 1

        if self.m_selected[itemId] == 0 then
            self:OnFilterChanged(self.m_selectedFilterTags)
        end
    end

    local cell = self:_GetCellByIndex(luaIndex)
    if cell then
        self:_RefreshSingleItemSelect(cell.listCellFriendshipUpgrade)
    end

    self:_RefreshSelectedFriendshipIncrease()
    self:_RefreshButtonState()
end




FriendShipPresentCtrl._SelectOnlyOneCell = HL.Method(HL.Number) << function(self, luaIndex)
    local isMax = self:_IsMax()
    if isMax then
        for index = 1, self.view.bottomList.scrollList.count do
            local cell = self:_GetCellByIndex(index)
            if cell then
                cell.listCellFriendshipUpgrade.selectNode.gameObject:SetActive(index == luaIndex)
            end
        end
    end
end




FriendShipPresentCtrl._GetCellByIndex = HL.Method(HL.Number).Return(HL.Any) << function(self, luaIndex)
    local cell
    if luaIndex > 0 then
        local object = self.view.bottomList.scrollList:Get(CSIndex(luaIndex))
        if object then
            cell = self.m_getGiftItemCell(object)
        end
    end
    return cell
end





FriendShipPresentCtrl._RefreshSingleItemSelect = HL.Method(HL.Table) << function(self, itemCell)
    local itemId = itemCell.item.id
    local selectNum = self.m_selected[itemId] or 0
    itemCell.multiSelectNode.gameObject:SetActive(selectNum > 0)
    itemCell.selectCount.text = tostring(selectNum)
    itemCell.btnMinus.gameObject:SetActive(selectNum > 0)
    itemCell.selectNode.gameObject:SetActive(selectNum > 0)
end





FriendShipPresentCtrl._RefreshTips = HL.Method(HL.Boolean, HL.Opt(HL.String)) << function(self, visible, itemId)
    local describeTips = self.view.bottomList.describeTips
    if visible then
        describeTips.animationWrapper:ClearTween(true)
        describeTips.gameObject:SetActive(visible)
    else
        describeTips.animationWrapper:PlayOutAnimation(function()
            describeTips.gameObject:SetActive(visible)
        end)
    end

    if self.m_itemTagCellCache == nil then
        self.m_itemTagCellCache = UIUtils.genCellCache(describeTips.collectionTagNode.tagCell)
    end

    if visible then
        local itemData = Tables.itemTable:GetValue(itemId)
        local giftData = Tables.giftItemTable:GetValue(itemId)

        local preferTagId = giftData.giftPreferTag
        local preferTagName = Tables.tagDataTable[preferTagId].tagName
        describeTips.areaTxt.text = preferTagName

        local areaIcon = self:_GetPreferTagIcon(preferTagId)
        if areaIcon and areaIcon ~= "" then
            describeTips.areaIcon:LoadSprite(UIConst.UI_SPRITE_SHIP, areaIcon)
        end

        local isPreferTagMatch = self:_GetCharPreferTagMatch(itemId)
        if isPreferTagMatch then
            
            describeTips.loveNode.gameObject:SetActive(true)
        else
            
            describeTips.loveNode.gameObject:SetActive(false)
        end
        
        

        local tagList = giftData.tagList
        self.m_itemTagCellCache:Refresh(#tagList, function(cell, index)
            local tagId = tagList[CSIndex(index)]
            local tagName = Tables.tagDataTable[tagId].tagName
            cell.nameTxt.text = tagName;
            if lume.find(self.m_charTagData.hobbyTagIds, tagId) ~= nil then
                cell.stateController:SetState("Conform")
            else
                cell.stateController:SetState("NotCompliant")
            end
        end)

        
        local iconId = itemData.iconId
        describeTips.itemIcon:LoadSprite(UIConst.UI_SPRITE_ITEM_BIG, iconId)

        describeTips.textName.text = itemData.name
        describeTips.textDesc.text = itemData.desc

        describeTips.buttonTips.onClick:RemoveAllListeners()
        describeTips.buttonTips.onClick:AddListener(function()
            self:Notify(MessageConst.SHOW_ITEM_TIPS, {
                transform = describeTips.buttonTips.transform,
                itemId = itemId,
            })
        end)
    end
end




FriendShipPresentCtrl._ClearSelected = HL.Method() << function(self)
    self.m_selected = {}
    self.m_curSelectedNum = 0
    self.m_curSelectedIncrease = 0
    self.m_curIncreaseInfo = {}

    
    for index = 1, self.view.bottomList.scrollList.count do
        local cell = self:_GetCellByIndex(index)
        if cell then
            self:_RefreshSingleItemSelect(cell.listCellFriendshipUpgrade)
        end
    end

    self:_RefreshSelectedFriendshipIncrease()
    self:_RefreshButtonState()
end




FriendShipPresentCtrl._RefreshButtonState = HL.Method() << function(self)
    if self:_IsMax() then
        return
    end

    local buttonSendStateController = self.view.bottomList.buttonSendState
    if self:_IsTodayMax() then
        buttonSendStateController:SetState("DisableState")
        self.view.bottomList.nodeClear.gameObject:SetActive(false)
        self.view.bottomList.emptyNode.gameObject:SetActive(false)
        return
    end

    if self.m_curSelectedNum <= 0 then
        self.view.bottomList.buttonSend.gameObject:SetActive(false)
        self.view.bottomList.nodeClear.gameObject:SetActive(false)

        self.view.bottomList.emptyNode.gameObject:SetActive(true)
    else
        self.view.bottomList.emptyNode.gameObject:SetActive(false)

        self.view.bottomList.buttonSend.gameObject:SetActive(true)
        self.view.bottomList.nodeClear.gameObject:SetActive(true)
        buttonSendStateController:SetState("NormalState")
    end

    if DeviceInfo.usingController then
        self:_RefreshInputKeyHint(self.m_focusItemId, self.m_focusLuaIndex)
    end
end



FriendShipPresentCtrl._SendPresentToChar = HL.Method() << function(self)
    if self.m_curSelectedNum <= 0 then
        self:Notify(MessageConst.SHOW_TOAST, Language.LUA_SPACESHIP_GIFT_COUNT_NONE)
        return
    end

    local giftIds = {}
    local nums = {}
    local keys = lume.keys(self.m_selected)
    table.sort(keys)

    for _, giftId in ipairs(keys) do
        table.insert(giftIds, giftId)
        table.insert(nums, self.m_selected[giftId])
    end

    self.view.bottomList.buttonSendState:SetState("ActiveState")
    GameInstance.player.spaceship:SendGiftToChar(self.m_charId, giftIds, nums);
end

HL.Commit(FriendShipPresentCtrl)