-- We got to do this shit because enqueueInventory calls enqueueItem
-- And enqueueItem calls enqueueInventory
-- So unless we define them both before using them
-- We will get an error saying either is undefined
local enqueueItem
local enqueueSlot
local enqueueInventory
local _

---@param item Barotrauma.Item
---@param queue Barotrauma.Item[]
---@param predicate? fun(item: Barotrauma.Item): boolean
---@return Barotrauma.Item[], string?
enqueueItem = function(item, queue, predicate)
    queue = queue or {}
    predicate = predicate or function() return true end
    -- debugPrint(string.format("Enqueuing item: %s", item.Prefab.Identifier.Value))
    -- local err
    -- This should make it breadth first, right...?
    -- No, not yet...
    local ok, stop = predicate(item)
    if ok then
        queue[#queue + 1] = item
    end
    if stop then return queue, "Stop" end
    if item.OwnInventory then
        -- As far as I know every item has only one inventory
        -- Only machines have multiple
        -- So inventrorY should be fine here
        -- debugPrint("Item has its own inventory, enqueuing inventory...")
        queue, _ = enqueueInventory(item.OwnInventory, queue, predicate)
        -- if err then
        --     debugPrint(string.format("Error enqueuing inventory: %s", err))
        -- end
    end
    -- debugPrint(string.format("Item enqueued. Current queue size: %d", #queue))
    return queue, nil
end

---@param slot Barotrauma.ItemInventory.Slot
---@param queue Barotrauma.Item[]
---@param predicate? fun(item: Barotrauma.Item): boolean
---@return Barotrauma.Item[], string?
enqueueSlot = function(slot, queue, predicate)
    queue = queue or {}
    predicate = predicate or function() return true end
    -- debugPrint(string.format("Enqueuing slot with %d items.", #slot.items))
    -- We don't want to shadow queue
    local err
    -- If the slot is empty there's nothing to iterate
    -- And we will naturally return queue as is
    for _, item in ipairs(slot.items) do
        -- Only the final leaf nodes decide upon the predicate
        queue, err = enqueueItem(item, queue, predicate)
        if err then
            return queue, err
        end
    end
    -- debugPrint(string.format("Finished enqueuing slot. Current queue size: %d", #queue))
    return queue
end

---@param inventory Barotrauma.ItemInventory
---@param queue Barotrauma.Item[]
---@param predicate? fun(item: Barotrauma.Item): boolean
---@return Barotrauma.Item[], string?
enqueueInventory = function(inventory, queue, predicate)
    queue = queue or {}
    predicate = predicate or function() return true end
    -- debugPrint(string.format("Enqueuing inventory with %d slots.", #inventory.slots))
    local err
    for _, slot in ipairs(inventory.slots) do
        -- Only the final leaf nodes decide upon the predicate
        queue, err = enqueueSlot(slot, queue, predicate)
        if err then
            return queue, err
        end
    end
    -- debugPrint(string.format("Finished enqueuing inventory. Current queue size: %d", #queue))
    return queue
end

return {
    enqueueItem = enqueueItem,
    enqueueSlot = enqueueSlot,
    enqueueInventory = enqueueInventory
}