Storage

local m = {}

    --List valid inventory types
    m.validStorageInventories = {
    "actuallyadditions:giantchestlarge",
    "actuallyadditions:giantchestmedium",
    "actuallyadditions:giantchest",
    "yabba:item_barrel",
    "yabba:antibarrel"
    }

    --Create a new storage database object
    function m:newStorage(network)
        if network == nil then error("Network provided is invalid or does not exist") end
        local storage = {}
        storage.network = network
        storage.inventories = {}
        storage.inventoryNames = {}
        storage.masterTable = {}

        --Do all the startup stuff for making a new storage DB
        function storage:init()
            --Init the table of connected inventoy names
            self.inventoryNames = self:indexStorageInventories()

            --Setup inventories as tables so we can actually use them
            for i=1, #self.inventoryNames do
                self.inventories[i] = {}
                self.inventories[i].items = self:generateItemStacks(self.inventoryNames[i])
            end

            --Generate the storage master table
            self.masterTable = self:generateMasterTable()
        end

        --Test function
        function storage:test()
            for i=1, #self.inventories do

            end
        end

        --Move an item from storage to a specified inventory
        function storage:moveItemTo(target, item, quantity)
            if target == nil then error("no inventory provided") end
            local currentItem = nil
            local quantityRetrieved = 0

            for i=1, #self.inventories do

                for k,v in pairs(self.inventories[i].items) do
                    currentItem = self.inventories[i].items[k]

                    if currentItem.name == item then
                        if self.masterTable[currentItem.name].count < quantity then
                            print("Insufficient quantity, only " .. self.masterTable[currentItem.name].count .. " " .. currentItem.name .. "(s) in storage.")
                            sleep(1.1)
                        elseif currentItem.count >= quantity then
                            self.network.callRemote(target, "pullItems", currentItem.parentInventory,k, quantity)
                            currentItem.count = currentItem.count - quantity
                            self.masterTable[currentItem.name].count = self.masterTable[currentItem.name].count - quantity
                            quantityRetrieved = quantityRetrieved + quantity
                            if quantityRetrieved >= quantity then break end
                            print("Retrieved")
                            sleep(0.75)
                        end
                    end
                end

            end
        end

        --Get the amount of open slots in a given inventory
        function storage:getAvailableSpace(inv)
            if inv ~= nil then
                local invSize = self.network.callRemote(inv, "size")
                local slotsOccupied = 0

                if invSize > 0 then
                    local invList = self.network.callRemote(inv, "list")

                    for k,v in pairs(invList) do
                        slotsOccupied = slotsOccupied + 1
                    end
                else
                    return 0
                end
                return invSize - slotsOccupied
            else
                error("expected inventory, got nil")
            end
        end

        --Test a given inventory against the list of valid types of storage inventories
        function storage:isStorageInventory(inv)
            local invType = network.callRemote(inv , "getTypeRemote")

            for i=1, #m.validStorageInventories do
                if invType == m.validStorageInventories[i] then
                    return true
                end
            end
            return false
        end

        --Get a list of valid attached storage inventories
        function storage:indexStorageInventories()
            local allPeripherals = network.getNamesRemote()
            local storageInventories = {}

            for i=1, #allPeripherals do
                for j=1, #m.validStorageInventories do
                    if network.getTypeRemote(allPeripherals[i]) == m.validStorageInventories[j] then
                        table.insert(storageInventories, allPeripherals[i])
                    end
                end
            end
            return storageInventories
        end

        --Create a set of itemStacks for a given inventory
        function storage:generateItemStacks(inv)
            if inv == nil then error("Expected inventory") end
            local invList = self.network.callRemote(inv, "list")
            local invItemStacks = {}

            for k,v in pairs(invList) do
                local currentItem = self.network.callRemote(inv, "getItemMeta", k)
                local itemStack = {}

                itemStack.name = currentItem.displayName
                itemStack.count = currentItem.count
                itemStack.rawName = currentItem.rawName
                itemStack.id = currentItem.name
                itemStack.oredic = currentItem.ores
                itemStack.parentInventory = inv

                invItemStacks[k] = itemStack
            end

            return invItemStacks
        end

        --Create a master storage table of contents of all inventories for fast checking
        function storage:generateMasterTable()
            local masterTable = {}

            for i=1, #self.inventories do

                for k,v in pairs(self.inventories[i].items) do
                    if masterTable[v.name] == nil then
                        masterTable[v.name] = {}
                        masterTable[v.name].name = v.displayName
                        masterTable[v.name].count = v.count
                        masterTable[v.name].rawName = v.rawName
                        masterTable[v.name].id = v.name
                        masterTable[v.name].oredic = v.ores
                    else
                        masterTable[v.name].count = masterTable[v.name].count + v.count
                    end
                end

            end

            return masterTable
        end

        return storage
    end

return m