-- Variable definitions
local valve, monitor, screenw, screenh
local serverID = nil
local clients = {}
local args = {...}
local redlimit, redside, on
local sides = {"left", "right", "top", "bottom", "front", "back"};

----------------------------------------------------
-- Function definitions
----------------------------------------------------
local liquidColors = {{"Water", colors.blue },
                        {"tile.oilStill", colors.gray, "Oil"},
                        {"Creosote Oil", colors.brown},
                        {"Essence", colors.lime},
                        {"Steam", colors.lightGray},
                        {"Honey", colors.yellow},
                        {"Ethanol", colors.orange},
                        {"Lava", colors.orange},
                        {"item.fuel", colors.yellow, "Fuel"},
                        {"Biomass", colors.green},
                        {"Fortron", colors.lightBlue},
                        {"Sludge", colors.black},
                        {"Liquid DNA", colors.magenta},
                        {"Fruit Juice", colors.green},
                        {"Seed Oil", colors.yellow},
                        {"Liquid Force", colors.yellow},
                        {"Oil", colors.black, "Oil"},
                        {"Fuel", colors.yellow, "Fuel"},
                        {"uumatter", colors.purple, "UUMatter"},
                        {"vegetable", colors.magenta, "Veg"},
                        {"deuterium", colors.lightBlue, "Deuterium"},
--liquid names for OpenPeripherals 0.2.1 by AmigaLink
                        {"creosote", colors.brown, "Creosote Oil"},
                        {"essence", colors.lime, "Essence"},
                        {"steam", colors.lightGray, "Steam"},
                        {"honey", colors.yellow, "Honey"},
                        {"bioethanol", colors.orange, "Ethanol"},
                        {"lava", colors.orange, "Lava"},
                        {"biomass", colors.green, "Biomass"},
                        {"fortron", colors.lightBlue, "Fortron"},
                        {"sludge", colors.black, "Sludge"},
                        {"liquiddna", colors.magenta, "Liquid DNA"},
                        {"fruitjuice", colors.green, "Fruit Juice"},
                        {"seedoil", colors.yellow, "Seed Oil"},
                        {"xpjuice", colors.lime, "XP Juice"},
                        {"liquidforce", colors.yellow, "Liquid Force"},
                        {"oil", colors.gray, "Oil"},
                        {"fuel", colors.yellow, "Fuel"},
                        {"milk", colors.white, "Milk"},
-- Life Essence suggested by Fyrhtu
                        {"life essence", colors.red, "Life Essence"},
-- My liquids
                        {"nitrofuel", colors.green, "Nitrofuel"}
                    }

local function getLiquidColor(liquid)
    for c, color in pairs (liquidColors) do
        if (liquid == color[1]) then
            return color[2],color[3] or liquid
        end
    end
    return colors.white, liquid;
end

local function getDeviceSide(deviceType)
    for i, side in pairs(sides) do
        if (peripheral.isPresent(side)) then
            if (peripheral.getType(side)) == string.lower(deviceType) then
                return side;
            end
        end
    end
end

local function showLevel(count, max, filled, color, label, amt, threshold, signal)
    local screenw, screenh = monitor.getSize()
    screenw = screenw / 2
    screenh = screenh / 2
    max = max + 1
    if (not screenw) then
        return nil;
        -- monitor has been broken
    end

    local starty = screenh -  math.floor((screenh * filled))
    local width  = math.ceil(screenw / max + .5)
    local offset = math.ceil(width * (count - 1))
    local amtw = string.len(amt)
    local thresholdy = (threshold and ( screenh - ((threshold / 100) * screenh)))

    if (count == max) then
    --  the final column should use up the remaining space.  A hack!
        width = screenw - offset
    end
    --truncate the label to the width of the bar.
    label = string.sub(label, 1, math.max((width - 1), 0))

    if (thresholdy and thresholdy < 1) then
        thresholdy = 1
    else
        if (thresholdy and thresholdy > screenh) then
            thresholdy = screenh
        end
    end

    term.redirect(monitor)
    for c=starty, screenh + 1, 1 do
        for line=0, width, 1 do
            paintutils.drawPixel(line + offset, c, color)
        end
    end
    if (thresholdy) then
        local thresholdColor = color
        for line=0, width, 1 do
            thresholdColor = color
            if (signal) then
                thresholdColor = colors.red
            else
                -- makes a dotted line when there is no redstone signal
                if (line % 2 == 0) then
                    thresholdColor = colors.red
                end
            end
            paintutils.drawPixel(line + offset, thresholdy, thresholdColor)
        end
    end

    monitor.setBackgroundColor(color)
    if (color == colors.white) then
        monitor.setTextColor(colors.black)
    end

    labely = math.min((starty + 1), screenh - 1)
    monitor.setCursorPos(offset + 1, labely)
    write(label)

    if (amtw <= width) then
        amty = math.min(labely + 1, screenh)
        monitor.setCursorPos(offset + 1, amty)
        write(amt)
    end
    monitor.setTextColor(colors.white)
    -- term.restore()
end

local function tankStats(tank)
    if(tank) then
        local amt = tank["amount"]
        local size = tank["capacity"]
        local filled = (amt and 1 / (size / amt)) or 0
        return amt, size, filled
    else
        return nil;
    end
end

local function tableCount(t)
    local total=0
    for k,v in pairs (t) do
        total = total + 1
    end
    return total
end

local function updateDisplay()
    local total = tableCount(clients)
    local count = 1

    monitor.setBackgroundColor(colors.black)
    monitor.setTextScale(.5)
    monitor.clear()

    for ix,client in pairs (clients) do
        local tank = client[1]
        local threshold = client[2]
        local signalOn = client[3]
        local amt,size,filled = tankStats(tank)
        local kind = tank["name"]
        local color,name = getLiquidColor(kind)
        local unit = ""
        local amount = math.max(amt or 0, 0)

        if (amount > 1000000) then
            unit="M"
            amount=string.format("%.2f", math.floor(amt / 1000) / 1000)
        else
            if (amount > 0) then
                unit="K"
                amount=string.format("%.2f", amt / 1000)
            else
                amount = ""
            end
        end
        amount = amount..unit
        showLevel(count, total, filled, color, name or "Empty", amount, threshold, signalOn)
        count = count + 1
    end
    return nil;
end

local function broadcast ()
    term.clear()
    term.setCursorPos(1,1)
    print("_____________ tankmon Server started __________")
    print("Broadcasting that tank display is available...")
    print("Hold Ctrl+T to Terminate.")
    while true do
        rednet.broadcast(os.getComputerID())
        -- term.setCursorPos(1, 5)
        -- term.clearLine()
        -- write("Connected tankmon clients: " .. tostring(tableCount(clients)))
        sleep(7)
    end
end

local function receive()
    while true do
        local senderID, message, distance = rednet.receive()
        if (message) then
            local data = textutils.unserialize(message)
            clients[senderID] = data
        end
    end
end

local function display()
    while true do
        updateDisplay()
        sleep(1.5)
    end
end

local function connect()
    print("Looking for a tankmon server in wireless Rednet range...")
    while true do
        local senderID, message, distance = rednet.receive()
        serverID = senderID
        print("Connected to server " .. tostring(serverID))
        sleep(3)
    end
end

local function publishTank()
    while true do
        if serverID then
            term.clear()
            term.setCursorPos(1,1)
            print("** Sending out tank information **")
            local tank = valve.getTankInfo("unknown")[1]

            -- establish whether redstone signal should be sent
            local amt,size,pctFilled = tankStats(tank)
            on = false
            local filled = pctFilled * 100
            if (filled and redlimit and redlimit==0 and filled==0) then
                on = true
            else
                if (filled and redlimit and filled <= redlimit) then
                    on=true
                end
            end
            if (redside) then
                rs.setOutput(redside, on)
            end

            -- use rednet to update the server with this tank's info.
            local info = {tank, redlimit, on}
            if (redlimit and redside) then
                print("Redstone threshold: " .. tostring(redlimit))
                print("Redstone output side: " .. redside)
                print("Redstone signal on: " .. tostring(on))
                print("")
            end
            term.clearLine()
            write("** Tank contains: " .. tostring(amt))
            rednet.send(serverID, textutils.serialize(info), false)
        end
        sleep(math.random(1,5))
    end
end

---------------------------------------
-- Main
---------------------------------------
local modemSide = getDeviceSide("modem");

if (modemSide) then
    local modem = peripheral.wrap(modemSide)
else
    error ("A wireless modem must be attached to this computer.")
end

local tankSide = getDeviceSide("iron_tank_valve");
local tankSide2 = getDeviceSide("steel_tank_valve");
local tankSide3 = getDeviceSide("rcsteeltankvalvetile");
local tankSide4 = getDeviceSide("rcirontankvalvetile");
local finalside = tankSide or tankSide2 or tankSide3 or tankSide4
local screenSide = getDeviceSide("monitor");

if (finalside and screenSide) then
      error("Either a screen or a tank valve can be connected, not both.")
end

if finalside  then
    valve = peripheral.wrap(finalside )
end

if (screenSide) then
    monitor = peripheral.wrap(screenSide)
    if (not monitor.isColor()) then
        error("The attached monitor must be Advanced. Get some gold!")
    end
    monitor.clear()
end

rednet.open(modemSide)
if (valve) then
    -- client mode
    redlimit = args[1]
    redside = args[2]
    if (redlimit and not redside) then
        print ("A threshold and redstone side must both be present.")
        print ("e.g. tankmon 100 top")
        error ()
    end
    if (redlimit) then
        redlimit = tonumber(redlimit)
        print("")
        print("Tank will send redstone signal at or below " .. tostring(redlimit) .. "% on side " .. redside)
    end
    -- clear outstanding redstone signals.
    for i,side in pairs(sides) do
        rs.setOutput(side, false)
    end
    parallel.waitForAll(connect, publishTank)
else
    -- server mode
    parallel.waitForAll(broadcast, receive, display)
end
rednet.close(modemSide)