raffinierie

settings.load()

-- #region Setup
local me_bridge = peripheral.wrap(settings.get("refinery.me_bridge"))
local fermenter_item = settings.get("refinery.fermenter_item")
local squeezer_item = settings.get("refinery.squeezer_item")
local refineries = {}

local recipient_id = settings.get("rednet.recipient")
local protocol = settings.get("rednet.protocol")
local modem_side = settings.get("rednet.modemSide")

local info = {
    refineries = {},
    storage_fermenter = {
        item = fermenter_item,
        amount = 0
    },
    storage_squeezer = {
        item = squeezer_item,
        amount = 0
    },
    storage_fuel = {
        amount = 0,
        max_amount = 4608
    }
}

for i, unit in pairs(settings.get("refinery.units")) do
    refineries[i] = {
        fermenter = peripheral.wrap(unit.fermenter),
        squeezer = peripheral.wrap(unit.squeezer),
        refinery = peripheral.wrap(unit.refinery),
        disable_threshold = unit.disable_threshold,
    }

    info.refineries[i] = {
        id = i,
        fermenter = "unknown",
        fermenter_storage = 0,
        fermenter_storage_max = 512,
        fermenter_tank = 0,
        fermenter_tank_max = 24000,
        squeezer = "unknown",
        squeezer_storage = 0,
        squeezer_storage_max = 512,
        squeezer_tank = 0,
        squeezer_tank_max = 24000,
        refinery = "unknown",
        refinery_tank_fermenter = 0,
        refinery_tank_fermenter_max = 24000,
        refinery_tank_squeezer = 0,
        refinery_tank_squeezer_max = 24000
    }
end

rednet.open(modem_side)
-- #endregion

local function is_saturated(machine)
    local storage_amount = 0
    local saturated = true
    for i = 1, machine.getInputSlotCount(), 1 do
        local stack = machine.getInputStack(i)
        if stack == nil then
           saturated = false
        else
            if stack.count < 56 then
                saturated = false
            end
            storage_amount = storage_amount + stack.count
        end
    end

    if not saturated then
        print("  is not saturated")
    end
    return saturated, storage_amount
end

local function is_item_stored(item_name, item_amount)
    local item = me_bridge.getItem({name = item_name})
    if item == nil or item.amount == nil then
        if item_amount < 1 then
            print("  minimum required item amount not defined")
            return true
        end
        print("  required items not stored")
        return false
    end
    if item.amount < item_amount then
        print("  not enough required items stored")
        return false
    end
    return true
end

local function get_storage()
    local item = me_bridge.getItem({name = fermenter_item})
    local amount = 0
    if fermenter_item ~= nil then
        amount = fermenter_item.amount
    end
    info.storage_fermenter.amount = amount

    item = me_bridge.getItem({name = squeezer_item})
    amount = 0
    if squeezer_item ~= nil then
        amount = squeezer_item.amount
    end
    info.storage_squeezer.amount = amount

    info.storage_fuel.amount = me_bridge.getUsedFluidStorage()
    info.storage_fuel.max_amount = me_bridge.getTotalFluidStorage()
end

local function check_unit(unit_id)
    print("Checking Fermenter "..unit_id)
    local is_fermenter_saturated, fermenter_items_stored = is_saturated(refineries[unit_id].fermenter)
    local is_fermenter_stored = is_item_stored(fermenter_item, refineries[unit_id].disable_threshold)
    if is_fermenter_saturated and is_fermenter_stored then
        print("  -> enabled")
        refineries[unit_id].fermenter.setEnabled(true)
        info.refineries[unit_id].fermenter = "enabled"
    else
        print("  -> disabled")
        refineries[unit_id].fermenter.setEnabled(false)
        info.refineries[unit_id].fermenter = "disabled"
    end
    info.refineries[unit_id].fermenter_storage = fermenter_items_stored
    info.refineries[unit_id].fermenter_tank = refineries[unit_id].fermenter.getFluid().amount

    print("Checking Squeezer "..unit_id)
    local is_squeezer_saturated, squeezer_items_stored = is_saturated(refineries[unit_id].squeezer)
    local is_squeezer_stored = is_item_stored(squeezer_item, refineries[unit_id].disable_threshold)
    if is_squeezer_saturated and is_squeezer_stored then
        print("  -> enabled")
        refineries[unit_id].squeezer.setEnabled(true)
        info.refineries[unit_id].squeezer = "enabled"
    else
        print("  -> disabled")
        refineries[unit_id].squeezer.setEnabled(false)
        info.refineries[unit_id].squeezer = "disabled"
    end
    info.refineries[unit_id].squeezer_storage = squeezer_items_stored
    info.refineries[unit_id].squeezer_tank = refineries[unit_id].squeezer.getFluid().amount


    if refineries[unit_id].fermenter.isRunning() then
        info.refineries[unit_id].fermenter = "active"
    end
    if refineries[unit_id].squeezer.isRunning() then
        info.refineries[unit_id].squeezer = "active"
    end
    if refineries[unit_id].refinery.isRunning() then
        info.refineries[unit_id].refinery = "active"
    elseif refineries[unit_id].refinery.getEnabled() then
        info.refineries[unit_id].refinery = "enabled"
    else
        info.refineries[unit_id].refinery = "disabled"
    end
    info.refineries[unit_id].refinery_tank_fermenter = refineries[unit_id].refinery.getRightInputFluid().amount
    info.refineries[unit_id].refinery_tank_squeezer = refineries[unit_id].refinery.getLeftInputFluid().amount
end

local function send_update()
    print("Sending update via [" .. protocol .. "] to PC" .. recipient_id)
    rednet.send(recipient_id, info, protocol)
    print("Update sent")
end

while true do
    for i, _ in ipairs(refineries) do
        check_unit(i)
    end
    get_storage()
    send_update()
    sleep(5)
end