reactor.display

local Display = {}

local storageBanks = {}
local reactorStats = nil
local scrapStatus = "UNKNOWN"
local reactorStatus = "UNKNOWN"
local coolingStatus = "UNKNOWN"
local condensators = 0
local outputStats = nil
local light = peripheral.wrap("bottom")

rednet.open("right")

function Display.setup()
    Display.monitor = peripheral.wrap("top")
    term.redirect(Display.monitor)
    x, y = term.getSize()
    Display.xSize = x
    Display.ySize = y
end

function Display.drawSpinner(rad)
    term.setBackgroundColor(colors.white)
    term.clear()

    -- draw loading text
    midX = Display.xSize/2
    midY = Display.ySize/2
    term.setTextColor(colors.black)
    term.setCursorPos(midX-5, midY + 4)
    term.write("Loading...")

    -- draw center dot
    term.setCursorPos(midX, midY)
    term.setBackgroundColor(colors.blue)
    term.write(" ")

    -- draw spinner dot
    term.setBackgroundColor(colors.red)
    term.setCursorPos(midX + (2.1 * math.cos(rad)), midY + (2.1 * math.sin(rad)))
    term.write(" ")
end

do
    local rad = 0
    local inc = (2 * math.pi) / 10
    function Display.spinner()
        Display.drawSpinner(rad)
        rad = (rad + inc) % (2 * math.pi)
    end
end

local function calculateEnergyTotal()
    local rtn = { capacity = 0, stored = 0}
    for k,v in pairs(storageBanks) do
        rtn.capacity = rtn.capacity + v.capacity
        rtn.stored = rtn.stored + v.stored
    end
    return rtn
end

function Display.drawStorage(history, startX, startY)
    currentStorage = calculateEnergyTotal()
    term.setBackgroundColor(colors.white)
    term.setTextColor(colors.black)
    term.setCursorPos(startX, startY)
    io.write("Storage System: ")
    if currentStorage.capacity then
        term.setTextColor(colors.green)
        print("ONLINE")
        term.setBackgroundColor(colors.white)
        term.setTextColor(colors.black)
        io.write("        Stored: ")

        term.setBackgroundColor(colors.green)
        stored = (currentStorage.stored/currentStorage.capacity) * 10
        for i=1,stored do
            term.write(" ")
        end
        term.setBackgroundColor(colors.red)
        for i=1,10-stored do
            term.write(" ")
        end
        term.setBackgroundColor(colors.white)
        term.setTextColor(colors.black)
        term.write(" ")
        print(math.floor((currentStorage.stored/currentStorage.capacity) * 100, 2).."%")
        term.write("      Capacity: ")
        term.setTextColor(colors.green)
        print(currentStorage.capacity)
    else
        term.setTextColor(colors.red)
        print("OFFLINE")
    end
end

function Display.drawReactorStatus(reactorStatus, startX, startY)
    term.setBackgroundColor(colors.white)
    term.setCursorPos(startX, startY)
    term.setTextColor(colors.black)
    local color = colors.red
    term.write("Reactor:        ")
    if reactorStatus == "ONLINE" then
        color = colors.green
    end
    term.setTextColor(color)
    print(reactorStatus)
    if reactorStats then
        term.setTextColor(colors.black)
        term.write("       Runtime: ")
        term.setTextColor(color)
        print(reactorStats.runTime)
        term.setTextColor(colors.black)
        term.write("  Total Output: ")
        term.setTextColor(color)
        print(reactorStats.totalOutput)
    end
end

function Display.drawCobblestone(scrapStatus, startX, startY)
    term.setBackgroundColor(colors.white)
    term.setCursorPos(startX, startY)
    term.setTextColor(colors.black)
    local color = colors.red
    term.write("Scrap System:   ")
    if scrapStatus == "ONLINE" then
        color = colors.green
    end
    term.setTextColor(color)
    print(scrapStatus)
    term.setTextColor(colors.black)
    term.write("  Cobble Gen:   ")
    term.setTextColor(color)
    print(cobbleStatus)
    term.setTextColor(colors.black)
    term.write("    Mass Fab:   ")
    term.setTextColor(color)
    print(massfabStatus)
end

function Display.drawCoolingSystem(coolingStatus, startX, startY)
    term.setBackgroundColor(colors.white)
    term.setCursorPos(startX, startY)
    term.setTextColor(colors.black)
    local color = colors.red
    term.write("Cooling System: ")
    if coolingStatus == "ONLINE" then
        color = colors.green
    end
    term.setTextColor(color)
    print(coolingStatus)
    term.setTextColor(colors.black)
    term.write("  Condensators: ")
    term.setTextColor(color)
    print(condensators)
end

function Display.drawOutput(startX, startY)
    term.setBackgroundColor(colors.white)
    term.setCursorPos(startX, startY)
    term.setTextColor(colors.black)
    if outputStats then
        term.write("Output EU/t:    ")
        print(util.commavalue(outputStats.output))
        term.write("Total Output:   ")
        print(util.commavalue(outputStats.total))
    end
end


function Display.refresh()
    term.setBackgroundColor(colors.white)
    term.clear()
    Display.drawStorage(storageHistory, 1, 1)
    Display.drawReactorStatus(reactorStatus, 1, 5)
    Display.drawCobblestone(scrapStatus, 1, 9)
    Display.drawCoolingSystem(coolingStatus, 1, 13)
    Display.drawOutput(1, 16)
end

Display.setup()


local reactorMonitorId = 507
local storageSystemId = nil
local coolingSystemId = nil
local cobblestoneSystemId = nil
local outputSystemId = 502

local function handleReactorMonitor(senderId, message)
    if message.command == "announce" then
        reactorMonitorId = senderId
        rednet.send(reactorMonitorId, textutils.serialize{type="reactor", sender="stats", command="ack"})
    elseif message.command == "ack" then
        reactorMonitorId = senderId
    elseif message.command == "stats" then
        -- reactor monitor stats
        reactorStatus = message.stats.status and "ONLINE" or "OFFLINE"
        if message.stats.status then
            light.setColorRGB(0, 255, 0)
        else
            light.setColorRGB(255, 0, 0)
        end
        reactorStats = message.stats
    end
end

local function handleStorageSystem(senderId, message)
    if message.command == "announce" then
        storageSystemId = senderId
        rednet.send(storageSystemId, textutils.serialize{type="reactor", sender="stats", command="ack", id = message.id})
    elseif message.command == "ack" then
        storageSystemId = senderId
    elseif message.command == "stats" then
        -- storage stats
        storageBanks[message.id] = message.stats
    end
end

local function handleCoolingSystem(senderId, message)
    if message.command == "announce" then
        coolingSystemId = senderId
        rednet.send(coolingSystemId, textutils.serialize{type="reactor", sender="stats", command="ack"})
    elseif message.command == "ack" then
        coolingSystemId = senderId
    elseif message.command == "stats" then
        coolingStatus = message.stats.coolingStatus
        condensators = message.stats.condensatorsReplaced
    end
end

local function handleCobblestoneSystem(senderId, message)
    if message.command == "announce" then
        cobblestoneSystemId = senderId
        rednet.send(cobblestoneSystemId, textutils.serialize{type="reactor", sender="stats", command="ack"})
    elseif message.command == "ack" then
        cobblestoneSystemId = senderId
    elseif message.command == "stats" then
        -- cobblestone stats
        scrapStatus = message.stats.systemStatus
        cobbleStatus = message.stats.cobbleStatus
        massfabStatus = message.stats.massfabStatus
    end
end

local function handleOutputSystem(senderId, message)
    if message.command == "announce" then
        outputSystemId = senderId
        rednet.send(outputSystemId, textutils.serialize{type="reactor", sender="stats", command="ack"})
    elseif message.command == "ack" then
        outputSystemId = senderId
    elseif message.command == "stats" then
        outputStats = message.stats
    end
end

local function doNetwork()
    rednet.broadcast(textutils.serialize{type="reactor", sender="stats", command="announce"})
    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 == "storage" then
                handleStorageSystem(senderId, message)
            elseif message.sender == "cooling" then
                handleCoolingSystem(senderId, message)
            elseif message.sender == "cobblestone" then
                handleCobblestoneSystem(senderId, message)
            elseif message.sender == "output" then
                handleOutputSystem(senderId, message)
            end
        end
    end
end

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

local function doDisplay()
    light.setColorRGB(255, 0, 0)
    while true do
        if reactorStatus == "UNKNOWN" then
            Display.spinner()
            sleep(.1)
        else
            Display.refresh()
            sleep(1)
        end
    end
end

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


local rtn, error = pcall(startup)
if not rtn then
    print("Stats failed: " .. error)
end
term.clear()
term.restore()
print("Exiting.")