local util = api.require("util")
local sensor = peripheral.wrap("left")
rednet.open("right")
local config = dofile("storage.config")
local reactorMonitorId = nil
local statsSystemId = nil
local bankData = nil


local function handleReactorMonitor(senderId, message)
    if message.command == "announce" then
        reactorMonitorId = senderId
        rednet.send(senderId, textutils.serialize{type="reactor", sender="storage", command="ack", id=config.id})
    elseif message.command == "ack" and message.id == config.id then
        reactorMonitorId = senderId
    end
end


local function handleStatsSystem(senderId, message)
    if message.command == "announce" then
        statsSystemId = senderId
        rednet.send(storageSystemId, textutils.serialize{type="reactor", sender="storage", command="ack", id=config.id})
    elseif message.command == "ack" and message.id == config.id then
        statsSystemId = senderId
    end
end


local function doNetwork()
    print("Starting network...")
    rednet.broadcast(textutils.serialize{type="reactor", sender="storage", command="announce", id=config.id})
    while true do
        local event, senderId, data, distance = os.pullEvent("rednet_message")
        local message = textutils.unserialize(data)
        if message and message.type == "reactor" then
            if message.sender== "monitor" then
                handleReactorMonitor(senderId, message)
            elseif message.sender == "stats" then
                handleStatsSystem(senderId, message)
            end
        end
    end
    print("network coro exiting")
end


local function drawMFSUs()
    print("MFSUs:")
    print("-------------------------------------")
    for i = 1, #bankData.mfsus, 4 do
        local blockOne = bankData.mfsus[i]
        local blockTwo = bankData.mfsus[i+1]
        local blockThree = bankData.mfsus[i+2]
        local blockFour = bankData.mfsus[i+3]
        local blockOneOutput = blockOne and string.format("%3d%%", blockOne.Stored / blockOne.Capacity * 100) or "    "
        local blockTwoOutput = blockTwo and string.format("%3d%%", blockTwo.Stored / blockTwo.Capacity * 100) or "    "
        local blockThreeOutput = blockThree and string.format("%3d%%", blockThree.Stored / blockThree.Capacity * 100) or "    "
        local blockFourOutput = blockFour and string.format("%3d%%", blockFour.Stored / blockFour.Capacity * 100) or "    "
        print(string.format("|  %s  |  %s  |  %s  |  %s  |", blockOneOutput, blockTwoOutput, blockThreeOutput, blockFourOutput))
    end
    print("-------------------------------------")
end

local function doMenu()
    print("Displaying menu...")
    while true do
        sleep(1)
        term.clear()
        term.setCursorPos(1,1)
        if bankData then
            print(string.format("EU Stored:     %s", util.commavalue(bankData.stored)))
            print(string.format("EU Capacity:   %s", util.commavalue(bankData.capacity)))
            print(string.format("EU Max output: %s", util.commavalue(bankData.maxOutput)))
            drawMFSUs()
        else
            print("Scanning for data...")
        end
        print("Press Q to exit")
    end
    print("menu coro exiting")
end

local function doKeyboard()
    print("Starting keyboard handler...")
    while true do
        local event, key = os.pullEvent("char")
        if string.lower(key) == "q" then
            break
        end
    end
    print("keyboard coro exiting")
end

local function sendStats()
    if reactorMonitorId then
        rednet.send(reactorMonitorId, textutils.serialize{type="reactor", sender="storage", command="capacity", id = config.id, stored = bankData.stored, capacity = bankData.capacity })
    end
    if statsSystemId then
        rednet.send(statsSystemId, textutils.serialize{type="reactor", sender="storage", command="stats", id = config.id, stats = bankData})
    end
end

local function scanForData(newData)
    local dataFound = false
    local targets = sensor.getTargets()
    local foundTarget = false
    if targets then
        for targetId, target in pairs(targets) do
            local position = util.strsplit(",", targetId)
            if target.type == "MFSU" and util.inBounds(config.volume, tonumber(position[1]), tonumber(position[2]), tonumber(position[3])) then
                local targetStats = sensor.getTargetDetails(targetId)
                if targetStats then
                    dataFound = true
                    table.insert(newData.mfsus, targetStats)
                    newData.capacity = newData.capacity + targetStats.Capacity
                    newData.stored = newData.stored + targetStats.Stored
                    newData.maxOutput = newData.maxOutput + targetStats.Output
                end
            end
        end
    end
    return dataFound
end

local homeX, homeY, homeZ = nil
local function doScanning()
    while true do
        local newData = { stored = 0, capacity=0, maxOutput=0, mfsus = {} }
        if not scanForData(newData) then break end
        bankData = newData
        sendStats()
        sleep(.5)
    end
    print("scanning coro exiting")
end


local function startup()
    term.clear()
    term.setCursorPos(1,1)
    parallel.waitForAny(doNetwork, doScanning, doKeyboard, doMenu)
end

local rtn, error = pcall(startup)
if not rtn then
    print("Storage scan failed: " .. error)
end
print("Exiting.")