CC to Hex Loader

local scanChest = "minecraft:chest_1"
local dropper = "botania:open_crate_2"
local hopper = "minecraft:hopper_2"
local clearCircle = "right"
local loadCircle = "left"
local hopperLock = "bottom"

local blockReader = peripheral.find("blockReader")

local nameToPattern = {
    minds_reflection="qaq",
    compass_purification="aa",
    alidades_purification="wa",
    archers_distilation="wqaawdd",
    break_block="qaqqqqq",
    architects_distilation="weddwaa",
    additive_distilation="waaw",
    conjure_light="qqd"
}

local patternToName = {}
for i,v in pairs(nameToPattern) do
    patternToName[v] = i
end

local letterToNum = {
w = 0,
q = 5,
a = 4,
e = 1,
d = 2,
}
local numToLetter = {}
for i,v in pairs(letterToNum) do
    numToLetter[v] = i
end

local tmpChests = peripheral.getNames()
local chests = {}
local emptySlots = {}
local nbtToPattern = {}


for i=1, #tmpChests do
    if tmpChests[i] ~= scanChest and tmpChests[i] ~= dropper and tmpChests[i]:find("chest") then
        table.insert(chests,peripheral.wrap(tmpChests[i]))
    end
end

local patternStorage = {}
local function addPatternToStorage(chest, slot, item)
    local pattern = nbtToPattern[item.nbt]
    if not patternStorage[pattern] then
        patternStorage[pattern] = {amount=1,variants={}}
        patternStorage[pattern].variants[item.nbt] = {{chest,slot,item.count}}
    else
        if not patternStorage[pattern].variants[item.nbt] then
            patternStorage[pattern].amount = patternStorage[pattern].amount + 1
            patternStorage[pattern].variants[item.nbt] = {{chest,slot,item.count}}
        else
            table.insert(patternStorage[pattern].variants[item.nbt],{chest,slot,item.count})
        end
    end
end
local function isHexHolder(itemName)
    return itemName == "hexcasting:slate" or itemName == "hexcasting:scroll_small" or itemName == "hexcasting:scroll_medium" or itemName == "hexcasting:scroll"
end
local function readScanChest()
    local scan = blockReader.getBlockData().Items
    local parsedScan = {}
    local items = #scan
    if not scan[0] then
        items = -1
    end
    for i=0, items do
        if isHexHolder(scan[i].id) and scan[i].tag then
            local pattern = {}
            if scan[i].tag.pattern then --scrolls
                pattern = scan[i].tag.pattern.angles
            else --slates
                pattern = scan[i].tag.BlockEntityTag.pattern.angles
            end
            local parsedPattern = ""
            for j=1, #pattern do
                parsedPattern = parsedPattern .. numToLetter[pattern[j]]
            end
            parsedScan[scan[i].Slot+1] = parsedPattern
        end
    end
    return parsedScan
end
local function transferToStorage(chestName,slot)
    local item = peripheral.call(chestName,"getItemDetail",slot)
    local amount = item.count
    if not isHexHolder(item.name) or not item.nbt then
        local targetLocation = table.remove(emptySlots)
        chests[targetLocation[1]].pullItems(chestName,slot,amount,targetLocation[2])
        return 0
    end
    local pattern = nbtToPattern[item.nbt]
    if not patternStorage[pattern] or not patternStorage[pattern].variants[item.nbt] then
        local targetLocation = table.remove(emptySlots)
        chests[targetLocation[1]].pullItems(chestName,slot,amount,targetLocation[2])
        addPatternToStorage(targetLocation[1], targetLocation[2], item)
        return 0
    end
    for i,v in pairs(patternStorage[pattern].variants[item.nbt])    do
        if v[3] + item.count <= 64 then
            v[3] = v[3] + item.count
            chests[v[1]].pullItems(chestName,slot,amount,v[2])
            return 0
        end
    end
    --if the variant doesn't exist in storage yet
    local targetLocation = table.remove(emptySlots)
    chests[targetLocation[1]].pullItems(chestName,slot,amount,targetLocation[2])
    addPatternToStorage(targetLocation[1], targetLocation[2], item)
end
local function transferFromStorage(chestName,slot,storageChestID,storageSlot, amount)
    local storageChest = chests[storageChestID]
    local item = storageChest.getItemDetail(storageSlot)
    if not amount then
        amount = item.count
    end
    storageChest.pushItems(chestName,storageSlot,amount,slot)
    if not isHexHolder(item.name) or not item.nbt then
        return 0
    end

    local pattern = nbtToPattern[item.nbt]
    if not pattern or not patternStorage[pattern] or not patternStorage[pattern].variants[item.nbt] then
        return 0
    end
    local toRemove = -1
    for i,v in pairs(patternStorage[pattern].variants[item.nbt]) do
        if v[1] == storageChestID and v[2] == storageSlot then
            v[3] = v[3] - item.count
            if v[3] <= 0 then
                toRemove = i
            end
            break
        end
    end
    if toRemove > 0 then
        table.remove(patternStorage[pattern].variants[item.nbt],toRemove)
        if #patternStorage[pattern].variants[item.nbt] == 0 then
            patternStorage[pattern].variants[item.nbt] = nil
            patternStorage[pattern].amount = patternStorage[pattern].amount - 1
        end
    end
end
function loadHexes(hexes)
    local hexUses = {}
    local parsedHex = {{}}
    local numIter = 1
    for i,v in pairs(hexes) do
        if nameToPattern[v] then
            local pattern = nameToPattern[v]
            if not patternStorage[pattern] or patternStorage[pattern].amount == 0 then
                error("You don't have any: " .. v .. " hexes!")
            end
            if not hexUses[pattern] then
                hexUses[pattern] = 0
            end
            hexUses[pattern] = hexUses[pattern] + 1
            if hexUses[pattern] <= patternStorage[pattern].amount then
                local curIter = 1
                for k,u in pairs(patternStorage[pattern].variants) do
                    if curIter == hexUses[pattern] then
                        table.insert(parsedHex[numIter],{pattern,k})
                        break
                    end
                    curIter = curIter + 1
                end
            else
                print("Adding iteration due to " .. v .. " being used more times than the number of variants stored (" .. (hexUses[pattern]) .. " times)")
                hexUses = {}
                hexUses[pattern] = 1
                numIter = numIter + 1
                parsedHex[numIter] = {}
                for k,u in pairs(patternStorage[pattern].variants) do
                    parsedHex[numIter][1] = {pattern,k}
                    break
                end
            end
        else
            error("The pattern: " .. v .. " is not recognized!")
        end
    end
    redstone.setOutput(clearCircle,false) -- ensure that it's off
    sleep(.1)
    redstone.setOutput(clearCircle,true)
    sleep(.1)
    redstone.setOutput(clearCircle,false)
    sleep(3)
    for i=1, #parsedHex do
        redstone.setOutput(hopperLock,false)
        sleep(.2)
        local curIter = parsedHex[i]
        for j=1, #curIter do
            local item = patternStorage[curIter[j][1]].variants[curIter[j][2]][1]
            chests[item[1]].pushItems(dropper,item[2],1,1)
        end
        redstone.setOutput(loadCircle,false) -- ensure that it's off
        sleep(.1)
        redstone.setOutput(loadCircle,true)
        sleep(.1)
        redstone.setOutput(loadCircle,false)
        sleep(7)
        redstone.setOutput(hopperLock,true)
        sleep(.2)
        local itemsInHopper = peripheral.call(hopper,"list")
        while itemsInHopper[1] or itemsInHopper[2] or itemsInHopper[3] or itemsInHopper[4] or itemsInHopper[5] do
            for i,v in pairs(itemsInHopper) do
                transferToStorage(hopper,i)
            end
            sleep(.5)
            itemsInHopper = peripheral.call(hopper,"list")
        end
    end
    redstone.setOutput(hopperLock,false)

end
local patternsToScan = {}
for i=1, #chests do
    local size = chests[i].size()
    local inv = chests[i].list()
    for j=1, size do
        if inv[j] then
            if isHexHolder(inv[j].name) and inv[j].nbt then
                if nbtToPattern[inv[j].nbt] then
                    addPatternToStorage(i,j,inv[j])
                else
                    if not patternsToScan[inv[j].nbt] then
                        patternsToScan[inv[j].nbt] = {amount=1,stacks={{i,j,inv[j].count}}}
                    else
                        table.insert(patternsToScan[inv[j].nbt].stacks,{i,j,inv[j].count})
                    end
                end
            end
        else
            table.insert(emptySlots,{i,j})
        end
    end
end

local stuffInScanChest = peripheral.call(scanChest,"list")
local scanChestSize = peripheral.call(scanChest,"size")
local scanChestScan = readScanChest()
for i, v in pairs(stuffInScanChest) do
    if not isHexHolder(v.name) or not v.nbt then
        transferToStorage(scanChest, i)
    else
        nbtToPattern[v.nbt] = scanChestScan[i]
        if patternsToScan[v.nbt] then
            for k,u in pairs(patternsToScan[v.nbt].stacks) do
                addPatternToStorage(u[1],u[2],chests[u[1]].getItemDetail(u[2]))
            end
            patternsToScan[v.nbt] = nil
        end
        transferToStorage(scanChest,i)
    end
end

for i,v in pairs(patternsToScan) do
    chests[v.stacks[1][1]].pushItems(scanChest,v.stacks[1][2],1,1)
    local scanChestScan = readScanChest()
    nbtToPattern[i] = scanChestScan[1]
    if not patternToName[scanChestScan[1]] then
        print("unregistered pattern: " .. scanChestScan[1] .. " !")
    end
    chests[v.stacks[1][1]].pullItems(scanChest,1,1,v.stacks[1][2])
    for k,u in pairs(v.stacks) do
        addPatternToStorage(u[1],u[2],chests[u[1]].getItemDetail(u[2]))
    end
end
patternsToScan = nil