orectrl.lua

local computer = require("computer")
local component = require("component")
local event = require("event")
local sides = require("sides")
local database = component.database
local mei = component.me_interface;
local rs = component.redstone;
local transposer = component.transposer;
local orectrl = {
    mTimerId = nil,
    mWashers = {
        {
            side    =  sides.east,
            address = component.me_exportbus.address,
            state   = 'notinitalized',
            lastState = 'n/a',
            name    = 'left2'
        }
        --{
        --    side    = sides.west,
        --    address = "8331c9e0-8685-4ef2-91a9-31fe0d722ef3",
        --    state   = 'notinitialized',
        --    lastState = 'n/a',
        --    name    = 'right2'
        --}
    },
    mDBInitialized = false,
    mOres = {},
    mValidOres = {},
    mOreMinSize = -1,
    mStats = {
        tickLast = 0,
        timeDiff = 0
    }
}
function orectrl.updateStats()
    local now = computer.uptime() * 20
    local timediff = now - orectrl.mStats.tickLast
    -- Did we advance at least one tick?
    if timediff <= 0 then
        -- We've already been called this tick. No need to do anything.
        -- This it NOT an optimization. Stuff will break if we continue.
        print("timediff to small");
        return false
    end
    if(orectrl.mDBInitialized == false) then
        for i=1,81 do
            local item = database.get(i);
            if(item ~= nil) then
                table.insert(orectrl.mOres, {
                    dbItem= item,
                    meSize = -1,
                    minSize = -1,
                    valid = false,
                    dbSlot = i
                });
            end
        end
        orectrl.mDBInitialized = true
        computer.pushSignal("orectrl_ore_added")
    end
    for _, washer in pairs(orectrl.mWashers) do
        local itemChest = transposer.getStackInSlot(washer.side, 1);
        if(washer["state"] == nil) then
            washer["state"] = 'notinitialized'
        end
        if (itemChest == nil and not (washer["state"] == 'empty' or string.find(washer["state"], 'invalid'))) then
            washer["state"] = "empty"
        elseif(itemChest ~= nil) then
            washer["state"] = itemChest.label
        end
    end
    orectrl.mOreMinSize = 5 --32+((#orectrl.mWashers)*64)
    orectrl.mValidOres = {}
    for _, ore in pairs(orectrl.mOres) do
        local meItem = mei.getItemsInNetwork({label=ore.dbItem.label});

        ore.minSize = orectrl.mOreMinSize
        if meItem[1] ~= nil then
            ore.meItem = meItem[1]
            ore.meSize = meItem[1].size
            if meItem[1].size >= orectrl.mOreMinSize then
                ore.valid = true
                table.insert(orectrl.mValidOres, ore)
            else
                ore.valid = false
            end
        else
            ore.valid = false
        end
    end
    orectrl.mStats.tickLast = now
    orectrl.mStats.timeDiff = timediff
    -- Fail for the first time so nobody can accidentally run the state machine and crash.
    return (timediff ~= now)
end

function orectrl.getWashers()
    return orectrl.mWashers
end

function orectrl.getOres()
    return orectrl.mOres
end

function orectrl.findValudOre()
end

function orectrl.runOnce()
    if not orectrl.updateStats() then
        print("stats update successfull");
        return
    end
    if #orectrl.mValidOres < 1 then
        return
    end

   for _, washer in pairs(orectrl.mWashers) do
        if(washer["state"] == 'empty' or string.match(washer["state"], 'invalid')) then
            local slot = math.random(1, #orectrl.mValidOres);
            local item = orectrl.mValidOres[slot];
            washer.lastState = washer.state
            if item ~= nil then
                component.proxy(washer.address).setExportConfiguration(sides.east, database.address, item.dbSlot);
                rs.setOutput(washer.side, 15);
                rs.setOutput(washer.side, 0);
                component.proxy(washer.address).setExportConfiguration(sides.east);
                washer.state = item.label;
            end
        end
    end
end

-- Service functions
function orectrl.start()
    if orectrl.mTimerId ~= nil then
        return false
    else
        orectrl.mTimerId = event.timer(1, orectrl.asyncTimerHandler, math.huge)
        return true
    end
end

function orectrl.stop()
    if orectrl.mTimerId == nil then
        return false
    else
        --event.ignore("component_added", grid_controller.asyncComponentAddedHandler)
        --event.ignore("component_removed", grid_controller.asyncComponentRemovedHandler)
        event.cancel(orectrl.mTimerId)
        orectrl.mTimerId = nil
        return true
    end
end

function orectrl.isRunning()
    return orectrl.mTimerId ~= nil
end

function orectrl.asyncTimerHandler()
    xpcall(orectrl.runOnce, function(...) io.stderr:write(debug.traceback(...) .. "\n") end)
end

return orectrl