ItemSortStore backup

---------------------------------------------Definition---------------------------------------------------------------
shutdown=false --initialization of shutdown parameter

ignorelist={"placeholder"}--not implemented

---------------------------------------------First time user entry:---------------------------------------------------------------
--Check if this is first time run, no saved choices on file
if (fs.exists("choices") == false) then
    while true do
            print("Please input pastebin ID of modemlist")

            local answer = read()
            if #answer~=8 then
                print("-Wrong answer, not correct length of pastebin ID-")
            else
                    pasteID=answer

                    break
            end
    end
--Save choices to file for future rrstarts
local file = fs.open("choices","w")
file.writeLine("pasteID=".."\""..pasteID.."\"")
file.close()
end

-- Read choices from file
os.loadAPI("choices")
pasteID = choices.pasteID
--print(pasteID)

--Load network modem IDs from pastebin file
if (fs.exists("modemfile") == true) then
    shell.run("delete","modemfile")
end
shell.run("pastebin","get",pasteID,"modemfile")--pasteID
os.loadAPI("modemfile") -- Reads choices from file
local storetype = modemfile.storetype --type of single item containers used for bulk storage
local modemlist = modemfile.modemlist
local storetypeRandom=modemfile.storetypeRandom --type of multi item containers used for random storage
local modemlistRandom=modemfile.modemlistRandom

--Combine modemlist with full network name
for i=1,#modemlist do
    for j=1,#modemlist[1] do
        modemlist[i][j]=storetype..tostring(modemlist[i][j])
        --print(modemlist[i][j])
    end
end
for i=1,#modemlistRandom do
    for j=1,#modemlistRandom[1] do
        modemlistRandom[i][j]=storetypeRandom..tostring(modemlistRandom[i][j])
        --print(modemlistRandom[i][j])
    end
end

---------------------------------------------Peripheral wrap---------------------------------------------------------------
--List all networked peripherals
local peripheralList = peripheral.getNames()
--Initialize crate modem peripheral list
local cratemodem={}
for i=1,#modemlist do
    cratemodem[i]={}
end
--wrap crate modems
for i=1,#modemlist do
    for j=1,#modemlist[1] do
        for index = 1, #peripheralList do
            if string.find(peripheralList[index], modemlist[i][j]) then --scan to see if names match
                cratemodem[i][j]=peripheral.wrap(peripheralList[index]) --wrap crate modems to array
            end
        end
    end
end
--Initialize chest modem peripheral list
local chestmodem={}
for i=1,#modemlistRandom do
    chestmodem[i]={}
end
--wrap chest modems
--print(textutils.serialize(modemlistRandom))

for i=1,#modemlistRandom do
    for j=1,#modemlistRandom[1] do
        for index = 1, #peripheralList do
            if peripheralList[index] == modemlistRandom[i][j] then --scan to see if names match
                chestmodem[i][j]=peripheral.wrap(peripheralList[index]) --wrap chest modems to array
            end
        end
    end
end
--print(textutils.serialize(chestmodem))



---------------------------------------------Functions---------------------------------------------------------------
local function StorageScan() --Scan crates and build array of items
-- Initialize item information tables
local itemMapName={}
local itemMapCount={}
local itemMapDamage={}
for i=1,#modemlist do
    itemMapName[i]={}
    itemMapCount[i]={}
    itemMapDamage[i]={}
end
--Start scan
for i=1,#cratemodem do
    for j=1,#cratemodem[1] do
        local iteminfo=cratemodem[i][j].list()
        if  iteminfo[1]~= nil then
            itemMapName[i][j]=iteminfo[1].name
            itemMapCount[i][j]=iteminfo[1].count
            itemMapDamage[i][j]=iteminfo[1].damage
        else
            itemMapName[i][j]="noitem"
            itemMapCount[i][j]=0
            itemMapDamage[i][j]=0
        end
        --print(i..","..j..": "..itemMapCount[i][j].." "..itemMapName[i][j].."/"..itemMapDamage[i][j])
    end
end
return itemMapName,itemMapCount,itemMapDamage
end


local function StorageScanRandom()
local itemMapNameRandom={}
local itemMapCountRandom={}
local itemMapDamageRandom={}

--Initialize "3d" tables
for i=1,#modemlistRandom do
        itemMapNameRandom[i]={}
        itemMapCountRandom[i]={}
        itemMapDamageRandom[i]={}
end
for i=1,#modemlistRandom do
    for j=1,#modemlistRandom[1] do
        itemMapNameRandom[i][j]={}
        itemMapCountRandom[i][j]={}
        itemMapDamageRandom[i][j]={}
    end
end
--save name, count and damage for all items in random storage
for i=1,#chestmodem do
    for j=1,#chestmodem[1] do
        chestlist=chestmodem[i][j].list()
        for k=1,chestmodem[i][j].size() do
            if  chestlist[k]~= nil then
                itemMapNameRandom[i][j][k]=chestlist[k].name
                itemMapCountRandom[i][j][k]=chestlist[k].count
                itemMapDamageRandom[i][j][k]=chestlist[k].damage
            else
                itemMapNameRandom[i][j][k]="noitem"
                itemMapCountRandom[i][j][k]=0
                itemMapDamageRandom[i][j][k]=0
            end
        end
    end
end
--print(textutils.serialize(itemMapNameRandom))
return itemMapNameRandom,itemMapCountRandom,itemMapDamageRandom
end --end function


--Find first empty in crate
local function findEmpty(itemMapName)
    for j=1,#itemMapName[1] do
        for i=1,#itemMapName do
            if string.find(itemMapName[i][j], "noitem") then
                return i,j,true
            end
        end
    end
    return 0,0,false
end


--Find first empty in chest
local function findEmptyRandom(itemMapNameRandom)
    for j=1,#itemMapNameRandom[1] do
        for i=1,#itemMapNameRandom do
            for k=1,#itemMapNameRandom[1][1] do
                if string.find(itemMapNameRandom[i][j][k], "noitem") then
                    return i,j,k,true
                end
            end
        end
    end
    return 0,0,0,false
end


---------------------------------------------Rednet prep---------------------------------------------------------------
--Rednet initialization
rednet.open("right")
--Find rednet IDs for crate turtles
local IDs={}
if rednet.lookup("ItemSortCrate") then
    for i=1,#modemlist do
        IDs[i]=rednet.lookup("ItemSortCrate","row"..i)
        --print(IDs[i])
    end
else
    print("No crate turtles found, shutting down!")
    shutdown=true
end
--Find IDs for random turtles
local Randomsearch={rednet.lookup("ItemSortRandom")}
if Randomsearch~=nil then
    IDsRandom={}
    for i=1,#Randomsearch do
        if rednet.lookup("ItemSortRandom","random"..i) then
            IDsRandom[i]=Randomsearch[i]
            print("Random turtle "..tostring(IDsRandom[i]).." found")
        end
    end
else
print("No random storage turtles found")
end


---------------------------------------------Execution---------------------------------------------------------------
if shutdown==false then
    print("Starting sorting operation")
end

-- Main loop
while shutdown==false do

--print("Starting crate sort")
--Scan network for items and build arrays of names and count
itemMapName,itemMapCount,itemMapDamage = StorageScan()


--Scan inputchest
inputChest=peripheral.wrap("top")
--print("Input chest contents:")
local sortlist={}  -- Format: sortlist={{itemname,damage,count},{itemname,damage,count},...}
local sortlistRandom={}
local sortcounter=1
local sortcounterRandom=1
for i=1,inputChest.size() do
    inputItem=inputChest.getItemMeta(i)
    if  inputItem~= nil then
        if inputItem.maxCount==1 then
            --print("Item: "..inputItem.name.."/"..inputItem.damage.." does not stack")
            sortlistRandom[sortcounterRandom]={inputItem.name,inputItem.damage,1,1}
            sortcounterRandom=sortcounterRandom+1
        else
            --print(inputItem.name.."/"..inputItem.damage)
            sortlist[sortcounter]={inputItem.name,inputItem.damage,inputItem.count,inputItem.maxCount}
            sortcounter=sortcounter+1
        end
    end
end

--Initialize sendlist
sendlist={}
for i=1,#modemlist do -------
    sendlist[i]={}
end

--Compare input chest with crates and add to sendlist if match is found
sortfound={}
for k=1,#sortlist do
    sortfound[k]=false
end
for i=1,#itemMapName do
    for j=1,#itemMapName[1] do
        for index = 1, #sortlist do
            if string.find(itemMapName[i][j], sortlist[index][1]) and string.find(itemMapDamage[i][j], sortlist[index][2]) then
                if #sendlist[i]==nil then --Check if first entry in sendlist
                    sendlist[i][1]={sortlist[index][1],sortlist[index][2],j}--Send itemname/damage/position j to turtle in row i
                else
                    sendlist[i][#sendlist[i]+1]={sortlist[index][1],sortlist[index][2],j}
                end
                print("Sort "..sortlist[index][1].."/"..sortlist[index][2].." @ "..i..","..j)
                sortfound[index]=true
            end
        end
    end
end

--If no existing crate was found for item, assign new crate
for k=1,#sortlist do
    if sortfound[k]==false then
        ie,je,freecrate=findEmpty(itemMapName)
        if freecrate==true then
            sendlist[ie][#sendlist[ie]+1]={sortlist[k][1],sortlist[k][2],je}
            itemMapName[ie][je]="reserved"
            print("Sort "..sortlist[k][1].."/"..sortlist[k][2].." to empty crate @ "..ie..","..je)
        else
            print("No available empty crates, sending "..sortlist[k][1].."/"..sortlist[k][2].." to random storage!")
            sortlistRandom[sortcounterRandom]={sortlist[k][1],sortlist[k][2],sortlist[k][3],sortlist[k][4]}
            sortcounterRandom=sortcounterRandom+1
        end
    end
end
--print(textutils.serialize(sortlistRandom)) --Prints list of items to be sorted to random storage

--Send sorting instructions for crates to turtles:
for i=1,#sendlist do
    rednet.send(IDs[i],sendlist[i])
end
--print("Ending crate sort")

if #sortlistRandom>0 then
--print("Starting chest sort")
--local x = os.clock()
--Build sendlistRandom for random storage
itemMapNameRandom,itemMapCountRandom,itemMapDamageRandom = StorageScanRandom()
--print(textutils.serialize(itemMapNameRandom))
--Initialize sendlistRandom
sendlistRandom={}
--Find chest and slot for random storage items
for s = 1, #sortlistRandom do
    local sortfoundrandom=false
    if sortlistRandom[s][4]>1 then
        for i=1,#itemMapNameRandom do
            for j=1,#itemMapNameRandom[1] do
                for k=1,#itemMapNameRandom[1][1] do
                    --if partly full stack exists
                    if string.find(itemMapNameRandom[i][j][k], sortlistRandom[s][1])
                                                and string.find(itemMapDamageRandom[i][j][k], sortlistRandom[s][2])
                                                            and itemMapCountRandom[i][j][k]<sortlistRandom[s][4] then
                        if sortlistRandom[s][3] <= sortlistRandom[s][4]-itemMapCountRandom[i][j][k] then --Input count < free space
                            sendAmount=sortlistRandom[s][3]
                        else
                            sendAmount=sortlistRandom[s][4]-itemMapCountRandom[i][j][k]--Input count > free space
                        end
                        itemMapCountRandom[i][j][k]=itemMapCountRandom[i][j][k]+sendAmount --Update scanned amount to new count
                        if #sendlistRandom==nil then --Check if first entry in sendlist
                            --name,damage,amount,i,j
                            sendlistRandom[1]={sortlistRandom[s][1],sortlistRandom[s][2],sendAmount,i,j,k}
                        else
                            sendlistRandom[#sendlistRandom+1]={sortlistRandom[s][1],sortlistRandom[s][2],sendAmount,i,j,k}
                        end
                        sortfoundrandom=true
                        break
                    end-----
                end
                if sortfoundrandom then break end
            end
            if sortfoundrandom then break end
        end
        if sortfoundrandom==false then
            ie,je,ke,freechest=findEmptyRandom(itemMapNameRandom)
            if freechest==true then
                print("Send "..sortlistRandom[s][1].."/"..sortlistRandom[s][2].." to empty slot in chest")
                if #sendlistRandom==nil then --Check if first entry in sendlist
                    sendlistRandom[1]={sortlistRandom[s][1],sortlistRandom[s][2],sortlistRandom[s][3],ie,je,ke}
                else
                    sendlistRandom[#sendlistRandom+1]={sortlistRandom[s][1],sortlistRandom[s][2],sortlistRandom[s][3],ie,je,ke}
                end
                itemMapNameRandom[ie][je][ke]="reserved"
            else
                print("Warning: No available storage for "..sortlistRandom[s][1].."/"..sortlistRandom[s][2].." found!")
            end
        end
    else --Item doesn't stack, send to empty slot
        ie,je,ke,freechest=findEmptyRandom(itemMapNameRandom)
        if freechest==true then
            print("Send "..sortlistRandom[s][1].."/"..sortlistRandom[s][2].." to empty slot in chest")
            if #sendlistRandom==nil then --Check if first entry in sendlist
                sendlistRandom[1]={sortlistRandom[s][1],sortlistRandom[s][2],sortlistRandom[s][3],ie,je,ke}
            else
                sendlistRandom[#sendlistRandom+1]={sortlistRandom[s][1],sortlistRandom[s][2],sortlistRandom[s][3],ie,je,ke}
            end
            itemMapNameRandom[ie][je][ke]="reserved"
        else
            print("Warning: No available storage for "..sortlistRandom[s][1].."/"..sortlistRandom[s][2].." found!")
        end
    end
end
--local xs=os.clock() - x
--print("Ending chest sort. Elapsed time: "..xs)
end

--Send sorting instructions to random storage turtles:
if Randomsearch~=nil and sendlistRandom~=nil then
    --print(textutils.serialize(sendlistRandom))
    rednet.send(IDsRandom[1],sendlistRandom)
    sendlistRandom=nil
end

sleep(#modemlist[1]*2+3)
end --end main loop