-- 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 / 4
        screenh = screenh / 4
        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

---------------------------------------
--the 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
    screenw, screenh = monitor.getSize()
    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)