local UIWidgetBase = require_ex('Common/Core/UIWidgetBase')

















































FacCacheSlot = HL.Class('FacCacheSlot', UIWidgetBase)


FacCacheSlot.m_slotIndex = HL.Field(HL.Number) << -1


FacCacheSlot.m_isFluid = HL.Field(HL.Boolean) << false


FacCacheSlot.m_itemInfo = HL.Field(HL.Table)


FacCacheSlot.m_isBlocked = HL.Field(HL.Boolean) << false


FacCacheSlot.m_cache = HL.Field(CS.Beyond.Gameplay.RemoteFactory.FBUtil.Cache)


FacCacheSlot.m_isInCache = HL.Field(HL.Boolean) << false


FacCacheSlot.m_onDropCallback = HL.Field(HL.Function)


FacCacheSlot.m_isDropEnabled = HL.Field(HL.Boolean) << true


FacCacheSlot.m_isQuickDropEnabled = HL.Field(HL.Boolean) << true


FacCacheSlot.m_producerInfo = HL.Field(HL.Userdata)





FacCacheSlot._OnFirstTimeInit = HL.Override() << function(self)
    self:_InitSlotDrag()
    self.view.liquidItemSlot.view.facLiquidBg:InitFacLiquidBg()
    self:RegisterMessage(MessageConst.ON_FAC_MOVE_ITEM_BAG_TO_CACHE, function(args)
        self:_OnMoveItemToCache(args)
    end)
    self:RegisterMessage(MessageConst.ON_FAC_MOVE_ITEM_DEPOT_TO_CACHE, function(args)
        self:_OnMoveItemToCache(args)
    end)
end




FacCacheSlot.InitFacCacheSlot = HL.Method(HL.Table) << function(self, slotData)
    self:_FirstTimeInit()

    if slotData == nil then
        return
    end

    self.m_slotIndex = slotData.slotIndex
    self.m_isFluid = slotData.isFluid
    self.m_itemInfo = slotData.itemInfo
    self.m_cache = slotData.cache
    self.m_isInCache = slotData.isInCache
    self.m_onDropCallback = slotData.onDropCallback or function() end
    self.m_lockFormulaId = slotData.lockFormulaId or ""
    self.m_producerInfo = slotData.producerInfo

    self:_InitItemSlot()
    self:_UpdateContent()
end








FacCacheSlot._OnClickItemSlot = HL.Method(HL.Forward('ItemSlot'), HL.Table) << function(self, itemSlot, info)
    if DeviceInfo.usingController then
        itemSlot.item:ShowActionMenu()
        return
    end

    if DeviceInfo.usingKeyboard then
        local mode = UIUtils.getMovingItemMode()
        if mode and not Utils.isDepotManualInOutLocked() then
            local inventoryArea = self:GetUICtrl().view.inventoryArea
            if inventoryArea then
                if Tables.liquidTable:ContainsKey(itemSlot.item.id) then
                    Notify(MessageConst.SHOW_TOAST, Language.LUA_ITEM_QUICK_DROP_LIQUID_FAIL)
                    return
                end
                local isMoveToItemBag = inventoryArea.m_isItemBag
                if isMoveToItemBag then
                    GameInstance.player.remoteFactory.core:Message_OpMoveItemCacheToBag(Utils.getCurrentChapterId(), self.m_cache.componentId, 0, CSIndex(self.m_slotIndex), mode)
                else
                    GameInstance.player.remoteFactory.core:Message_OpMoveItemCacheToDepot(Utils.getCurrentChapterId(), self.m_cache.componentId, CSIndex(self.m_slotIndex), mode)
                end
                return
            end
        end
    end

    itemSlot.item:SetSelected(true)
    itemSlot.item:ShowTips(nil, function()
        itemSlot.item:SetSelected(false)
    end)
end



FacCacheSlot._InitItemSlot = HL.Method() << function(self)
    self.view.itemSlot.gameObject:SetActiveIfNecessary(not self.m_isFluid)
    self.view.liquidItemSlot.gameObject:SetActiveIfNecessary(self.m_isFluid)
end



FacCacheSlot._GetCurrentItemSlot = HL.Method().Return(HL.Userdata) << function(self)
    return self.m_isFluid and self.view.liquidItemSlot or self.view.itemSlot
end



FacCacheSlot._UpdateContent = HL.Method() << function(self)
    local info = self.m_itemInfo
    local isEmpty = not info or string.isEmpty(info.id)

    local itemSlot = self:_GetCurrentItemSlot()
    local dragEnabled = not isEmpty and info.count ~= nil and info.count > 0
    if isEmpty then
        itemSlot:InitItemSlot()
        itemSlot.gameObject.name = "Item__" .. CSIndex(self.m_slotIndex)
    else
        if not dragEnabled then
            
            itemSlot.view.dragItem.enabled = false
        end
        itemSlot:InitItemSlot(info, function()
            self:_OnClickItemSlot(itemSlot, info)
        end)
        itemSlot.gameObject.name = "Item_" .. info.id
        itemSlot.item.view.button.clickHintTextId = "virtual_mouse_hint_item_tips"
    end
    if Tables.liquidTable:ContainsKey(info.id) then
        dragEnabled = false
    end
    itemSlot.view.dragItem.enabled = dragEnabled
    itemSlot.supportQuickMovingHalfItem = true
    if self.m_isFluid then
        self:_RefreshLiquidBg()
    else
        
        itemSlot.view.dropHintEmptyText.gameObject:SetActiveIfNecessary(isEmpty or info.count <= 0)
        itemSlot.view.dropHintFilledText.gameObject:SetActiveIfNecessary(not isEmpty and info.count > 0)
    end

    self.m_dropHelper = UIUtils.initUIDropHelper(itemSlot.view.dropItem, {
        acceptTypes = UIConst.FACTORY_REPO_DROP_ACCEPT_INFO,
        onDropItem = function(eventData, dragHelper)
            if self:_ShouldAcceptDrop(dragHelper) then
                self:_OnDropItem(dragHelper)
            end
        end,
        onToggleHighlight = function(active)
            self:_MobileRefreshDropHighlight(active)
        end
    })

    itemSlot.item.view.button.onIsNaviTargetChanged = function(active)
        if active then
            self:_RefreshSlotHoverBindingState()
        end
    end
    self:_RefreshSlotHoverBindingState()
    if isEmpty then
        return
    end

    if info.count > 0 then
        local data = Tables.itemTable:GetValue(info.id)
        local dragCount = math.min(info.count or 0, info.maxStackCount or 0)

        self.m_dragHelper = UIUtils.initUIDragHelper(itemSlot.view.dragItem, {
            source = UIConst.UI_DRAG_DROP_SOURCE_TYPE.Repository,
            type = data.type,

            repository = self.m_cache,
            isIn = self.m_isInCache,

            itemId = info.id,
            count = dragCount,
            cacheGridIndex = CSIndex(self.m_slotIndex),

            canFacCacheDrop = function(id)
                return self:_CheckIsValidProducerDropBagItem(id)
            end
        })
        itemSlot:InitPressDrag()

        if self.m_isFluid then
            local selectFillLiquidId = itemSlot.item:AddHoverBinding("common_quick_drop", function()
                Notify(MessageConst.ON_NAVI_INVENTORY_SELECT_FLUID, {
                    componentId = self.m_cache.componentId,
                    fluidId = ""
                })
            end)
            InputManagerInst:SetBindingText(selectFillLiquidId, Language.LUA_ITEM_ACTION_CACHE_SELECT_FILL_LIQUID)
        else
            itemSlot.item:AddHoverBinding("common_quick_drop", function()
                itemSlot:QuickDrop()
            end)
        end
    else
        local fakeGrayBinding = itemSlot.item:AddHoverBinding("common_quick_drop", function() end)
        if self.m_isFluid then
            InputManagerInst:SetBindingText(fakeGrayBinding, Language.LUA_ITEM_ACTION_CACHE_SELECT_FILL_LIQUID)
        end
        InputManagerInst:ForceBindingKeyhintToGray(fakeGrayBinding, true)
    end

    itemSlot.item.actionMenuArgs = {
        source = UIConst.UI_DRAG_DROP_SOURCE_TYPE.Repository,
        componentId = self.m_cache.componentId,
        cacheGridIndex = CSIndex(self.m_slotIndex),
        isFluidCacheSlot = self.m_isFluid,
        isInCacheSlot = self.m_isInCache,
    }
    InputManagerInst:SetBindingText(itemSlot.item.view.button.hoverConfirmBindingId, Language["key_hint_item_open_action_menu"])

    local color = info.count < info.maxStackCount and self.config.COLOR_NORMAL or self.config.COLOR_MAX_STACK
    local colorFormatterPrefix = string.format("<color=#%sff>", color)
    itemSlot.view.item:UpdateCountWithColor(info.count, colorFormatterPrefix .. "%s" .. "</color>")
end



FacCacheSlot._RefreshSlotHoverBindingState = HL.Method() << function(self)
    local itemInfo = self.m_itemInfo
    local itemSlot = self:_GetCurrentItemSlot()
    if not itemInfo or string.isEmpty(itemInfo.id) then
        InputManagerInst:ToggleBinding(itemSlot.item.view.button.hoverConfirmBindingId, false)
    end
    if not self.m_isQuickDropEnabled then
        InputManagerInst:ToggleGroup(itemSlot.item.view.button.hoverBindingGroupId, false)
    end
end



FacCacheSlot._RefreshLiquidBg = HL.Method() << function(self)
    if not self.m_isFluid then
        return
    end

    local count = 0
    local height = 0
    if not string.isEmpty(self.m_itemInfo.id) then
        count = self.m_itemInfo.count
        local maxCount = self.m_itemInfo.maxStackCount
        if maxCount > 0 then
            height = count / maxCount
        end
    end

    self.view.liquidItemSlot.view.facLiquidBg:RefreshLiquidHeight(height)
end







FacCacheSlot.m_dragHelper = HL.Field(HL.Forward('UIDragHelper'))



FacCacheSlot._InitSlotDrag = HL.Method() << function(self)
    self:RegisterMessage(MessageConst.ON_START_UI_DRAG, function(dragHelper)
        self:_OnStartUiDrag(dragHelper)
    end)
    self:RegisterMessage(MessageConst.ON_END_UI_DRAG, function(dragHelper)
        self:_OnEndUiDrag(dragHelper)
    end)
end




FacCacheSlot._OnStartUiDrag = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
    if dragHelper == nil then
        return
    end

    local itemSlot = self:_GetCurrentItemSlot()
    if self:_ShouldAcceptDrop(dragHelper) then
        itemSlot.view.dropItem.enabled = true
        itemSlot.view.dropHintNode.gameObject:SetActiveIfNecessary(true)
        if self.m_isFluid then
            
            self:_RefreshFluidSlotDropHintText(dragHelper.info.itemId)
        end
    else
        itemSlot.view.dropItem.enabled = false
    end
end




FacCacheSlot._OnEndUiDrag = HL.Method(HL.Forward('UIDragHelper')) << function(self, dragHelper)
    if dragHelper == nil then
        return
    end

    local itemSlot = self:_GetCurrentItemSlot()
    itemSlot.view.dropItem.enabled = false
    if self:_ShouldAcceptDrop(dragHelper) then
        itemSlot.view.dropHintNode.gameObject:SetActiveIfNecessary(false)
    end
end







FacCacheSlot.m_dropHelper = HL.Field(HL.Forward('UIDropHelper'))




FacCacheSlot._ShouldAcceptDrop = HL.Method(HL.Forward('UIDragHelper')).Return(HL.Boolean) << function(self, dragHelper)
    if not self.m_isDropEnabled then
        return false
    end

    if not self.m_dropHelper:Accept(dragHelper) then
        return false
    end

    if dragHelper.info.repository == self.m_cache then
        return false
    end

    local itemId = dragHelper.info.itemId
    local success, data = Tables.factoryItemTable:TryGetValue(itemId)
    if not success then
        return false
    end

    
    if data.itemState then
        return false
    end

    if self.m_isFluid then
        local isEmptyBottle, isFullBottle = self:_IsEmptyBottleDrop(itemId), self:_IsFullBottleDrop(itemId)

        
        if not isEmptyBottle and not isFullBottle then
            return false
        end

        
        if isEmptyBottle and string.isEmpty(self.view.liquidItemSlot.view.item.id) then
            return false
        end

        
        if not self.m_isInCache and not isEmptyBottle then
            return false
        end
    else
        
        if data.buildingBufferStackLimit <= 0 then
            return false
        end

        
        if not self.m_isInCache then
            return false
        end
    end

    return true
end





FacCacheSlot._OnDropItem = HL.Method(HL.Forward('UIDragHelper'), HL.Opt(CS.Proto.ITEM_MOVE_MODE)) << function(self, dragHelper, mode)
    local source = dragHelper.source
    local dragInfo = dragHelper.info
    local core = GameInstance.player.remoteFactory.core
    local componentId = self.m_cache.componentId
    mode = mode or (dragHelper.isHalfDragging and CS.Proto.ITEM_MOVE_MODE.HalfGrid or CS.Proto.ITEM_MOVE_MODE.Normal)
    if source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Storage then
        
        logger.error("未实现: 从工厂 Storage Drop 过来")
        return
    elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.Repository then
        
        if dragInfo.itemId then
            
            core:Message_OpMoveItemCacheToCache(Utils.getCurrentChapterId(), dragInfo.repository.componentId, dragInfo.itemId, componentId, mode)
        else
            
            logger.error("未实现: 从工厂 Repo Drop 过来, 尝试转移整个Repo")
            return
        end
    elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.FactoryDepot then
        
        if self:_IsFluidModeBottleDrop(dragInfo.itemId) then
            core:Message_OpFillingFluidComWithDepot(Utils.getCurrentChapterId(), componentId, dragInfo.itemId)
        else
            if self:_CheckIsValidItemInLockFormula(dragInfo.itemId) then
                if not self:_CheckIsValidProducerDropBagItem(dragInfo.itemId) then
                    Notify(MessageConst.SHOW_TOAST, Language["ui_fac_common_bag_drop_same_item"])
                    return
                end

                core:Message_OpMoveItemDepotToCache(Utils.getCurrentChapterId(), dragInfo.itemId, componentId, CSIndex(self.m_slotIndex), mode)
            end
        end
    elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.ItemBag then
        
        if self:_IsFluidModeBottleDrop(dragInfo.itemId) then
            core:Message_OpFillingFluidComWithBag(Utils.getCurrentChapterId(), componentId, dragInfo.csIndex)
        else
            if self:_CheckIsValidItemInLockFormula(dragInfo.itemId) then
                if not self:_CheckIsValidProducerDropBagItem(dragInfo.itemId) then
                    Notify(MessageConst.SHOW_TOAST, Language["ui_fac_common_bag_drop_same_item"])
                    return
                end

                core:Message_OpMoveItemBagToCache(Utils.getCurrentChapterId(), dragInfo.csIndex, componentId, CSIndex(self.m_slotIndex), mode)
            end
        end
    end

    if dragInfo.itemId then
        local cptHandler = FactoryUtils.getBuildingComponentHandler(componentId)
        local buildingNode = cptHandler.belongNode
        local worldPos = GameInstance.remoteFactoryManager.visual:BuildingGridToWorld(
                Vector2(buildingNode.transform.position.x, buildingNode.transform.position.z))
        EventLogManagerInst:GameEvent_FactoryItemPush(buildingNode.nodeId, buildingNode.templateId,
                GameInstance.remoteFactoryManager.currentSceneName, worldPos,
                dragInfo.itemId, dragInfo.count, self.m_cache.items)
    end
end




FacCacheSlot._IsFluidModeBottleDrop = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    return self.m_isFluid and (self:_IsEmptyBottleDrop(itemId) or self:_IsFullBottleDrop(itemId))
end




FacCacheSlot._IsEmptyBottleDrop = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    return Tables.emptyBottleTable:ContainsKey(itemId)
end




FacCacheSlot._IsFullBottleDrop = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    return Tables.fullBottleTable:ContainsKey(itemId)
end




FacCacheSlot._RefreshFluidSlotDropHintText = HL.Method(HL.String) << function(self, itemId)
    local isEmptyBottle, isFullBottle = self:_IsEmptyBottleDrop(itemId), self:_IsFullBottleDrop(itemId)
    if not isEmptyBottle and not isFullBottle then
        return
    end

    local text = isEmptyBottle and Language.LUA_ITEM_ACTION_FILL_LIQUID or Language.LUA_ITEM_ACTION_DUMP_LIQUID
    self.view.liquidItemSlot.view.dropHintText.text = text
end




FacCacheSlot._CheckIsValidProducerDropBagItem = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    if self.m_producerInfo == nil then
        return true
    end

    local checkCacheList = {
        self.m_producerInfo.cacheIn1,
        self.m_producerInfo.cacheIn2,
        self.m_producerInfo.cacheIn3,
        self.m_producerInfo.cacheIn4,
        self.m_producerInfo.cacheFluidIn1,
        self.m_producerInfo.cacheFluidIn2,
        self.m_producerInfo.cacheFluidIn3,
        self.m_producerInfo.cacheFluidIn4,
    }

    local checkFunc = function(cache)
        if cache == nil then
            return true
        end
        for id, _ in cs_pairs(cache.items) do
            if id == itemId then
                local success, order = cache.itemOrderMap:TryGetValue(id)
                if success and LuaIndex(order) ~= self.m_slotIndex then
                    return false
                end
            end
        end
        return true
    end

    for _, cache in pairs(checkCacheList) do
        local result = checkFunc(cache)
        if not checkFunc(cache) then
            return false
        end
    end

    return true
end




FacCacheSlot._MobileRefreshDropHighlight = HL.Method(HL.Boolean) << function(self, active)
    if not DeviceInfo.usingTouch then
        return
    end

    local itemSlot = self:_GetCurrentItemSlot()
    if not itemSlot.view.dropItem.enabled then
        return
    end

    itemSlot.view.dropHintDeco.gameObject:SetActiveIfNecessary(not active)
end




FacCacheSlot._OnMoveItemToCache = HL.Method(HL.Table) << function(self, args)
    local toComponentId, toGridIndex, itemId = unpack(args)
    if self.m_cache.componentId ~= toComponentId then
        return
    end
    if toGridIndex == CSIndex(self.m_slotIndex) then
        self.view.itemSlot:PlayDropAnimation()
        UIUtils.playItemDropAudio(itemId)
    end
end







FacCacheSlot.m_lockFormulaId = HL.Field(HL.String) << ""




FacCacheSlot._CheckIsValidItemInLockFormula = HL.Method(HL.String).Return(HL.Boolean) << function(self, itemId)
    if string.isEmpty(self.m_lockFormulaId) then
        return true
    end

    local success, craftData = Tables.factoryMachineCraftTable:TryGetValue(self.m_lockFormulaId)
    if not success then
        return true
    end

    local isValid = false
    for _, itemBundleGroup in pairs(craftData.ingredients) do
        for _, itemBundle in pairs(itemBundleGroup.group) do
            if itemBundle.id == itemId then
                isValid = true
                break
            end
        end
    end

    if not isValid then
        Notify(MessageConst.SHOW_TOAST, Language.LUA_FAC_FORBID_CHANGE_FORMULA)
    end

    return isValid
end









FacCacheSlot.ShowCacheSlotHint = HL.Method(HL.Boolean) << function(self, needShow)
    local slot = self:_GetCurrentItemSlot()
    slot.view.controllerMoveHintNode.gameObject:SetActive(needShow)
end









FacCacheSlot.RefreshSlotBlockState = HL.Method(HL.Boolean) << function(self, isBlocked)
    if self.m_isBlocked == isBlocked then
        return
    end

    local itemSlot = self:_GetCurrentItemSlot()
    local itemSlotView = itemSlot.view
    local itemView = itemSlotView.item.view
    UIUtils.PlayAnimationAndToggleActive(itemView.blockMaskAnimationWrapper, isBlocked)
    self.m_isBlocked = isBlocked
end



FacCacheSlot.GetNormalSlotLine = HL.Method().Return(HL.Userdata) << function(self)
    return self.view.itemSlot.view.facLineCell
end



FacCacheSlot.GetCurrentNormalSlotItemId = HL.Method().Return(HL.String) << function(self)
    return self.view.itemSlot.view.item.id
end





FacCacheSlot.PlaySlotAnimation = HL.Method(HL.String, HL.Opt(HL.Function)) << function(self, animationName, callback)
    if self.m_isBlocked then
        return
    end

    local slot = self:_GetCurrentItemSlot()
    slot.view.animationWrapper:PlayWithTween(animationName, callback)
end






FacCacheSlot.TryDropItem = HL.Method(HL.Forward('UIDragHelper'), HL.Boolean, HL.Opt(CS.Proto.ITEM_MOVE_MODE)).Return(HL.Boolean) << function(self, dragHelper, tryAllSlot, mode)
    if not self:CanDrop(dragHelper) then
        return false
    end

    
    if DeviceInfo.usingController and tryAllSlot then
        local source = dragHelper.source
        local dragInfo = dragHelper.info
        if source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.FactoryDepot then
            if not self:_IsFluidModeBottleDrop(dragInfo.itemId) then
                if self:_CheckIsValidItemInLockFormula(dragInfo.itemId) then
                    if not self:_CheckIsValidProducerDropBagItem(dragInfo.itemId) then
                        return false
                    end
                end
            end
        elseif source == UIConst.UI_DRAG_DROP_SOURCE_TYPE.ItemBag then
            if not self:_IsFluidModeBottleDrop(dragInfo.itemId) then
                if self:_CheckIsValidItemInLockFormula(dragInfo.itemId) then
                    if not self:_CheckIsValidProducerDropBagItem(dragInfo.itemId) then
                        return false
                    end
                end
            end
        end
    end

    self:_OnDropItem(dragHelper, mode)
    return true
end




FacCacheSlot.CanDrop = HL.Method(HL.Forward('UIDragHelper')).Return(HL.Boolean) << function(self, dragHelper)
    if not self:_ShouldAcceptDrop(dragHelper) then
        return false
    end

    return true
end




FacCacheSlot.SetSlotDropEnabled = HL.Method(HL.Boolean) << function(self, isEnabled)
    self.m_isDropEnabled = isEnabled
end



FacCacheSlot.IsNaviTarget = HL.Method().Return(HL.Boolean) << function(self)
    local slot = self:_GetCurrentItemSlot()
    return slot.item.view.button.isNaviTarget
end



FacCacheSlot.SetNaviTarget = HL.Method() << function(self)
    local slot = self:_GetCurrentItemSlot()
    InputManagerInst.controllerNaviManager:SetTarget(slot.item.view.button)
end




FacCacheSlot.SetSlotBtnEnabled = HL.Method(HL.Boolean) << function(self, enable)
    local slot = self:_GetCurrentItemSlot()
    slot.item.view.button.enabled = enable
end




FacCacheSlot.SetSlotBtnHoverBindingEnabled = HL.Method(HL.Boolean) << function(self, enable)
    local slot = self:_GetCurrentItemSlot()
    InputManagerInst:ToggleGroup(slot.item.view.button.hoverBindingGroupId, enable)
    self.m_isQuickDropEnabled = enable
end




FacCacheSlot.SetState = HL.Method(HL.String) << function(self, stateName)
    self.view.stateCtrl:SetState(stateName)
end




HL.Commit(FacCacheSlot)
return FacCacheSlot