--tankmon
--   Tank monitoring program edited by RikuSS4
--    Original program by Forgotten_Boy
--    Hardware detector program by Sharidan
--      Requires OpenPeripherals (OP). Tested with version 3.0.
--      Supports iron & steel Railcraft tanks, Open Block tanks, Ender Tanks, AE ExtraCells tanks,
--    TConstruct tanks, and Extra Utilities Drums.
--      Also supports multiple tanks, and tanks attached with modems.
--      If I missed any tanks, let me know. I will add it to the list.
--[[
 Setup:
 - Place an Advanced Computer with wireless modem and with tankmon on it adjacent to a tank.  Run "tankmon".
 - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.  Run "tankmon".
 - Your monitor should now show the contents of the tank.  Add as many tanks as you like and the server will simply add them to the display.
 - The size of the monitor or locations of the modems don't matter, place them anywhere on the computer.  The monitor can be resized while tankmon is running.

 Optional Setup:
 - Place an Advanced Computer with wired and wireless modems with lan cables connecting all tanks with lan modems attached to tanks and to computer.  Run "tankmon".
 - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor and/or terminal glass bridge.  Run "tankmon".
 - Your monitor should now show the contents of the tanks.  Add as many tanks as you like and the server will simply add them to the display.
 - The size of the monitor or locations of the modems don't matter, place them anywhere on the computer.  The monitor can be resized while tankmon is running.

 Advanced usage:
 - On the client, you can use tankmon to trigger a redstone signal when the tank reaches a certain threshold (specified as 0 to 100, a percentage).  For example:
 tankmon 100 left
 tankmon 0 top
 The first example will send redstone output on the left when the tank is full.  The second example will send redstone output on the top when the tank is empty.
--]]

-- 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"};
local tankTypes = {"rcirontankvalvetile","rcsteeltankvalvetile","iron_tank_valve", "steel_tank_valve", "openblocks_tank", "drum", "ender_tank", "cofh_thermalexpansion_tank", "net_minecraft_src_buildcraft_factory_tiletank", "tileentitycertustank", "tconstruct_lavatank"};
local scale = .5 --Scale for monitor text
local skipEmpty = true --Skip showing empty tanks
local count = 0 --Counter for tanks

----------------------------------------------------
-- Terminal Bridge Glasses Variable definitions
----------------------------------------------------
local bridge = {}
bridge["TankText"] = {}
bridge["TankBackground"] = {}
bridge["TankTexture"] = {}
-------------------------------------------------------
-- Terminal Bridge Glasses display variable definitions
-- Feel free to alter these to your liking
-------------------------------------------------------
bridge["BackgroundColor"] = 0x000000 --Background Bar color
bridge["TextColor"] = 0x33B5E5 --Text color
bridge["TextScale"] = 1 --Text Scale
bridge["ExtendBackground"] = true --Extend Black background behind text
bridge["BarWidth"] = 25 --Tank bar width
bridge["BarHeight"] = 50 --Tank bar height
bridge["XOffset"] = 5 --X Offset for displaying info
bridge["YOffset"] = 50 --Y Offset for displaying info
bridge["XSpacing"] = 5 --Space between columns
bridge["YSpacing"] = 5 --Space between rows
bridge["Alpha"] = 1 --Alpha value of bar background
bridge["LinesAmt"] = 3 --Number of text lines after tank bar
bridge["MaxCols"] = 3 --Max Number of cols to display per page
bridge["MaxRows"] = 3 --Max Number of rows to display per page
-------------------------------------------------------
-- Which row to start with. This will be changed to
-- automatically change based on user input in chat
-- command box.
-------------------------------------------------------
bridge["StartRow"] = 0 --Min Row to display
-------------------------------------------------------
-- Altering these does nothing
-------------------------------------------------------
bridge["CurrentRow"] = 1 --Current Row
bridge["CurrentCol"] = 1 --Current Col

----------------------------------------------------
-- Function definitions
----------------------------------------------------
local liquidNameColors = {
               {"water", colors.blue, "Water" },
               {"lava", colors.orange, "Lava" },
               {"liquidforce", colors.yellow, "Liquid Force" },
               {"turpentine", colors.brown, "Turpentine" },
               {"poison", colors.purple, "Poison" },
               {"latex", colors.white, "Latex" },
               {"ardite.molten", colors.orange, "Molten Ardite" },
               {"gold.molten", colors.yellow, "Molten Gold" },
               {"blood", colors.orange, "Blood" },
               {"copper.molten", colors.orange, "Molten Copper" },
               {"obsidian.molten", colors.gray, "Molten Obsidian" },
               {"bop.honey", colors.yellow, "Honey" },
               {"sap", colors.brown, "Sap" },
               {"liquidnitrogen", colors.cyan, "Liquid Nitrogen" },
               {"iron.molten", colors.gray, "Molten Iron" },
               {"bop.liquidpoison", colors.purple, "Liquid Poison" },
               {"alumite.molten", colors.orange, "Molten Ardite" },
               {"cobalt.molten", colors.cyan, "Molten Cobalt" },
               {"bop.springwater", colors.blue, "Spring Water" },
               {"glowstone", colors.yellow, "Energized Glowstone" },
               {"resin", colors.brown, "Resin" },
               {"emerald.liquid", colors.lime, "Liquified Emerald" },
               {"pinkslime", colors.pink, "Pink Slime" },
               {"redstone", colors.orange, "Destabilized Redstone" },
               {"xpjuice", colors.lime, "Liquid XP" },
               {"oil", colors.gray, "Oil" },
               {"aluminum.molten", colors.lightGray, "Molten Aluminum" },
               {"manyullyn.molten", colors.purple, "Molten Manyullyn" },
               {"stone.seared", colors.gray, "Seared Stone" },
               {"creosote", colors.green, "Creosote Oil" },
               {"sludge", colors.brown, "Sludge" },
               {"bioethanol", colors.lime, "Ethanol" },
               {"acid", colors.lime, "Acid" },
               {"biomass", colors.lime, "Biomass" },
               {"immibis.liquidxp", colors.lime, "Liquid XP" },
               {"electrum.molten", colors.yellow, "Molten Electrum" },
               {"sewage", colors.brown, "Sewage" },
               {"slime.blue", colors.cyan, "Liquid Blueslime" },
               {"tin.molten", colors.lightGray, "Molten Tin" },
               {"aluminumbrass.molten", colors.orange, "Molten Aluminum Brass" },
               {"milk", colors.white, "Milk" },
               {"fuel", colors.lime, "Fuel" },
               {"biofuel", colors.green, "Biofuel" },
               {"chocolatemilk", colors.brown, "Chocolate Milk" },
               {"glass.molten", colors.lightGray, "Molten Glass" },
               {"cryotheum", colors.cyan, "Gelid Cryotheum" },
               {"pyrotheum", colors.orange, "Blazing Pyrotheum" },
               {"pinkslime", colors.pink, "Pink Slime" },
               {"platinum.molten", colors.cyan, "Molten Platinum" },
               {"coal", colors.gray, "Liquifacted Coal" },
               {"lead.molten", colors.gray, "Molten Lead" },
               {"mushroomsoup", colors.brown, "Mushroom Soup" },
               {"silver.molten", colors.lightGray, "Molten Silver" },
               {"nickel.molten", colors.cyan, "Molten Nickel" },
               {"ender", colors.green, "Resonant Ender" },
               {"invar.molten", colors.lightGray, "Molten Invar" },
               {"glue", colors.white, "Glue" },
               {"meat", colors.pink, "Meat" },
               {"steel.molten", colors.gray, "Molten Steel" },
               {"bronze.molten", colors.brown, "Molten Bronze" }
               }

function cls()
   term.clear()
   term.setCursorPos(1,1)
   term.setCursorBlink(false)
end
function clm()
   if monitor then
      monitor.setBackgroundColor(colors.black)
      monitor.setTextScale(scale)
      monitor.clear()
      monitor.setCursorPos(1,1)
      monitor.setCursorBlink(false)
   end
end
function clb()
   if bridge["peripheral"] then
      bridge["peripheral"].clear()
   end
end

function table.merge(tbl1, tbl2)
   for k,v in ipairs(tbl2) do
      table.insert(tbl1, v)
   end
   return tbl1
end

function split(str, wordNum)
   local splitString = {}
   for tmp in str:gmatch("%w+") do
      table.insert(splitString, tmp)
   end
   return splitString[wordNum] or ""
end

local function getLiquidColor(liquid)
   for c, color in pairs (liquidNameColors) do
      if (liquid == color[1]) or (liquid == color[3]) then
         return color[2]
      end
   end
   return colors.white;
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

function hardwareDetector(...)
  local self = {}
  -- Initialize internal hardware list
  self._devList = {}

  -- Internal worker function
  -- Checks a boolean value and returns the
  -- corresponding supplied value
  local function iif(bool, resultTrue, resultFalse)
    if (bool) then
      return resultTrue;
    else
      return resultFalse;
    end
  end
  local function split(str, pat)
    local t = {}
    local fpat = "(.-)" .. pat
    local last_end = 1
    local s, e, cap = str:find(fpat, 1)
    while s do
      if s ~= 1 or cap ~= "" then
        table.insert(t,cap)
      end
      last_end = e+1
      s, e, cap = str:find(fpat, last_end)
    end -- while
    if last_end <= #str then
      cap = str:sub(last_end)
      table.insert(t, cap)
    end
    return t
  end
  local function splitType(str)
    local typ, adv = str, nil
    local r = split(str, ":")
    if (#r == 2) then
      typ = r[1]
      adv = r[2]
    end
    return typ, adv;
  end
  local function wrapID(value)
    if (value == nil) then
      return "offline"
    else
      return tostring(value)
    end
  end
  local function addDevice(label, devType, remote)
    local lcdt = string.lower(devType)
    local adv = "n/a";
    local pCall = function() end;
    if (remote) then
      pCall = function(label, method)
        return remote.callRemote(label, method)
      end;
    else
      pCall = function(label, method)
        return peripheral.call(label, method)
      end;
    end
    if (lcdt == "modem") then
      adv = iif(pCall(label, "isWireless"), "wireless", "cable")
    elseif (lcdt == "monitor") then
      adv = iif(pCall(label, "isColor"), "advanced", "normal")
    elseif (lcdt == "computer" or lcdt == "turtle") then
      adv = tostring(wrapID(pCall(label, "getID")))
    elseif (lcdt == "drive") then
      if (disk.isPresent(label)) then
        if (disk.hasData(label)) then
          adv = "floppy";
        elseif (disk.hasAudio(label)) then
          adv = "music";
        else
          adv = "unknown";
        end
      else
        adv = "empty"
      end
    end
    table.insert(self._devList, {label, devType, adv});
    if (lcdt == "modem" and string.lower(adv) == "cable") then
      return true;
    end
  end

  -- Detects all connected peripherals
  function self.detect()
    self._devList = {};
    local sides = rs.getSides();
    local remoteSide = {};
    for i, side in pairs(sides) do
      local devType = peripheral.getType(side);
      if (devType) then
        if (addDevice(side, devType)) then
          table.insert(remoteSide, side);
        end
      end -- if
    end -- for-do

    if (#remoteSide > 0) then
      -- There was a cable modem attached, so we need to loop through all remote peripherals too
      for r = 1, #remoteSide do
        local rp = peripheral.wrap(remoteSide[r]);
        local lst = rp.getNamesRemote()
        for r = 1, #lst do
          local name = lst[r]
          local devType = rp.getTypeRemote(name);
          if (devType) then
            addDevice(name, devType, rp);
          end
        end
      end -- for r
    end
  end

  -- Returns a tuple of the first matching peripheral
  function self.find(...)
    local args={...}
    if (#args > 0) then
      local idx = 0;
      for i, sideType in pairs(self._devList) do
        for a = 1, #args do
          local findType = args[a];
          if (type(findType) == "string") then
            local typ, adv = splitType(findType);
            if (string.lower(typ) == string.lower(self._devList[i][2])) then
              if (adv) then
                if (string.lower(adv) == string.lower(self._devList[i][3])) then
                  -- We found a device of this type
                  idx = i;
                end
              else
                -- We found a device of this type
                idx = i;
              end
              if (idx > 0) then
                return tostring(self._devList[idx][1]), tostring(self._devList[idx][2]), tostring(self._devList[idx][3])
              end
            end
          end
        end
      end
      return nil;
    else
      error("No device type specified.", 0)
    end
  end

  -- Returns a complete list of peripherals
  function self.getAll()
    return self._devList;
  end

  -- Returns a list of all matching peripherals
  function self.getList(...)
      local args={...}
      local results = {}
      if (#args > 0) then
         for i, sideType in pairs(self._devList) do
            for a = 1, #args do
               local findType = args[a];
               if (type(findType) == "string") then
                  if (string.lower(findType) == string.lower(self._devList[i][2])) then
                     -- We found a device of this type
                     table.insert(results, {tostring(self._devList[i][1]), tostring(self._devList[i][2]), tostring(self._devList[i][3])})
                  end
               elseif (type(findType) == "table") then
                  for i2, entry in pairs(findType) do
                     if (type(entry) == "string") then
                        if (string.lower(entry) == string.lower(self._devList[i][2])) then
                           -- We found a device of this type
                           table.insert(results, {tostring(self._devList[i][1]), tostring(self._devList[i][2]), tostring(self._devList[i][3])})
                        end
                     end
                  end
               end
            end
         end
         return results;
      else
         error("No device type specified.", 0);
      end
   end

  -- Determines if the device is remote or not
  function self.isRemote(dev)
    if (type(dev) == "string") then
      local sides = rs.getSides();
      for i, s in pairs(sides) do
        if (string.lower(dev) == string.lower(s)) then
          return nil;
        end
      end
      return true;
    else
      error("Device connect string expected.", 0);
    end
  end

  -- Internal calls, don't mess with these
  self.detect()

  local args = {...};
  if (#args > 0) then
    return self.find(...);
  else
    -- If no parameters were passed,
    -- return the hardware object
    return self;
  end
end

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

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

      if (count == total) then
      --  the final column should use up the remaining space.  A hack!
         width = screenw - offset
      end

      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
               else
                  thresholdColor = color
               end
            end
            paintutils.drawPixel(line + offset, thresholdy, thresholdColor)
         end
      end

      --truncate the label to the width of the bar.
      monLabel = string.sub(rawLabel, 1, math.max((width - 1), 0))

      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)
      monitor.setTextScale(scale)
      write(monLabel)

      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
   if (bridge["peripheral"]) then
      --Maximum length string can be
      local cutoffPoint = math.ceil(bridge["BarWidth"] / (8*bridge["TextScale"]))

      bridge["CurrentRow"] = math.floor((count+bridge["MaxCols"]-1)/bridge["MaxCols"])
      bridge["CurrentCol"] = ((count+bridge["MaxCols"]-1) - bridge["CurrentRow"]*bridge["MaxCols"]) + 1

      if (bridge["CurrentRow"] > bridge["StartRow"]) and (bridge["CurrentRow"] <= (bridge["StartRow"] + bridge["MaxRows"])) then
         --Heigth including extra lines below tank display
         local fullHeight = bridge["BarHeight"]+((8*bridge["TextScale"])*(bridge["LinesAmt"]))
         --X and Y coords for tank displays
         local x = bridge["XOffset"] + ((bridge["BarWidth"] + bridge["XSpacing"]) * (bridge["CurrentCol"]-1))
         local y = bridge["YOffset"] + ((fullHeight+bridge["YSpacing"])*(bridge["CurrentRow"]-bridge["StartRow"]-1))
         --Draw tank background using liquid texture
         if bridge["ExtendBackground"] then
            bridge["TankBackground"][count] = bridge["peripheral"].addBox(x,y,bridge["BarWidth"],fullHeight,bridge["BackgroundColor"],bridge["Alpha"])
         else
            bridge["TankBackground"][count] = bridge["peripheral"].addBox(x,y,bridge["BarWidth"],bridge["BarHeight"],bridge["BackgroundColor"],bridge["Alpha"])
         end
         bridge["TankTexture"][count] = bridge["peripheral"].addLiquid(x+1,y+1+math.ceil(bridge["BarHeight"]-(bridge["BarHeight"] * filled)),bridge["BarWidth"]-2,(bridge["BarHeight"] * filled)-2,label)
         --Display info to bridge
         bridge["TankText"][count] = bridge["TankText"][count] or {}
         for i=0,(bridge["LinesAmt"]-1) do
            bridge["TankText"][count][i] = bridge["peripheral"].addText((x+2), (bridge["BarHeight"]+y+((8*bridge["TextScale"])*i)),"",bridge["TextColor"])
            bridge["TankText"][count][i].setScale(scale)
         end
         bridge["TankText"][count][0].setText(string.sub(split(rawLabel,1), 1, cutoffPoint))
         bridge["TankText"][count][1].setText(string.sub(split(rawLabel,2), 1, cutoffPoint))
         bridge["TankText"][count][2].setText(string.sub(tostring(math.floor(filled*100)).."%", 1, cutoffPoint))
      end
   end
end

local function tankStats(tank)
    if(tank) then
      local name = tank["name"] or nil
      local rawName = tank["rawName"] or nil
        local amt = tank["amount"]
        local size = tank["capacity"]
        local filled = (amt and 1 / (size / amt)) or 0
      local threshold = tank["redLimit"] or -1
      local signalOn = tank["on"] or false
        return name, rawName, amt, size, filled, threshold, signalOn
    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

function printTable(tt, indent)
   print(tableToString(tt, indent))
end

function tableToString (tt, indent, done)
  done = done or {}
  indent = indent or 0
  if type(tt) == "table" then
    local sb = {}
    for key, value in pairs (tt) do
      table.insert(sb, string.rep (" ", indent)) -- indent it
      if type (value) == "table" and not done [value] then
        done [value] = true
        table.insert(sb, "{\n");
        table.insert(sb, tableToString (value, indent + 2, done))
        table.insert(sb, string.rep (" ", indent)) -- indent it
        table.insert(sb, "}\n");
      elseif "number" == type(key) then
        table.insert(sb, string.format("\"%s\"\n", tostring(value)))
      else
        table.insert(sb, string.format("%s = \"%s\"\n", tostring (key), tostring(value)))
       end
    end
    return table.concat(sb)
  else
    return tt .. "\n"
  end
end

function table.contains(tbl, element)
  for _, value in pairs(tbl) do
    if value == element then
      return true
    end
  end
  return false
end

local function findTank(tbl)
   if type(tbl) == "table" then
      for index,value in pairs(tbl) do
         if type(value) == "table" then
            if value["capacity"] then
               return tbl
            else
               return findTank(value)
            end
         end
      end
   else
      return nil
   end
end
local function findTanks(tbl)
   local tblTemp = {}
   if type(tbl) == "table" then
      for index,value in pairs(tbl) do
         if type(value) == "table" then
            if value["capacity"] then
               table.insert(tblTemp, value)
            else
               table.insert(tblTemp, findTank(value))
            end
         end
      end
   end
   return tblTemp
end
local function updateDisplay()
   --printTable(findTanks(clients))
--end
--local function tmp()
    local count = 1
   local lstTanks = {}
   local total = 0

   clm()
   clb()

   if tableCount(clients) > 0 then
      local i = 1
      for ix,client in pairs (clients) do
         local tanks = findTanks(client)
         table.merge(lstTanks, tanks)
         if (i <= 15) then
            term.setCursorPos(1,6+i)
            term.clearLine()
            print("Client "..i.." # of Tanks: "..tostring(#tanks))
         end
         i = i + 1
      end
      total = #lstTanks
      term.setCursorPos(1,6)
      term.clearLine()
      print("Total # of Tanks: "..tostring(total))
      for _,tankInfo in pairs (lstTanks) do
            local name, rawName, amt, size, filled, threshold, signalOn = tankStats(tankInfo)
            local color = getLiquidColor(rawName)
            local unit = ""
            local amount = math.max(amt or 0, 0)
            --print("Name: "..tostring(name))
            --print("Raw Name: "..tostring(rawName))
            --print("color: "..tostring(color))
            --print("amt: "..tostring(amt))
            --print("size: "..tostring(size))
            --print("filled: "..tostring(filled))

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

local function broadcast ()
    cls()
    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: " .. 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()
    cls()
   print("Looking for a tankmon server in range...")
    while true do
        local senderID, message, distance = rednet.receive()
        serverID = senderID
      print()
      print("Connected to server " ..tostring(serverID)..".")
      sleep(3)
  end
end

local function publishTank()
   while true do
      if (serverID) then
         local hw = hardwareDetector()
         lstTanks = hw.getList(tankTypes)
         if (type(lstTanks) == "table") then
            if (#lstTanks > 0) then
               local info = {}
               for i, tank in pairs(lstTanks) do
                  if not tank[1]["capacity"] then
                     lstTanks[i][1] = peripheral.wrap(lstTanks[i][1]).getTankInfo("unknown")[1]
                  end
               end
               cls()
               print("** Sending out tank information **")
               print("Number of tanks: "..#lstTanks)
               for i, tank in pairs(lstTanks) do
                  -- establish whether redstone signal should be sent
                  local name, rawName, amt, size, filled, threshold, signalOn = tankStats(tank[1])
                  on = false
                  pctFilled = filled * 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.
                  tank[1]["redLimit"] = redLimit
                  tank[1]["on"] = on
                  table.insert(info, tank[1])
                  if (redLimit and redside) then
                     print("Redstone signal on: " .. tostring(on))
                  end
                  if (i <= 12) then
                     term.setCursorPos(1,3 + i)
                     term.clearLine()
                     if tank[1]["amount"] then
                        write("** Tank "..i.." contains: " .. tostring(tank[1]["amount"]).."mB of "..tostring(tank[1]["name"]))
                     else
                        write("** Tank "..i.." is empty.")
                     end
                  end
               end
               if (redLimit and redside) then
                  print("Redstone threshold: " .. tostring(redLimit))
                  print("Redstone output side: " .. tostring(redside))
               end
               rednet.send(serverID, textutils.serialize(info), false)
            end
         end
        end
        sleep(math.random(1,5))
  end
end

-------------------------------------------------------
-- Hardware setup and detection
-------------------------------------------------------
local hw = hardwareDetector()
local screenSide, _, _ = hw.find("monitor:advanced");
local bridgeSide, _, _ = hw.find("openperipheral_glassesbridge");
local modemSide, _, _ = hardwareDetector("modem:wireless")
lstTanks = hw.getList(tankTypes)

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

if (#lstTanks > 0) and (bridgeSide or screenSide) then
    error("Either a screen or a tank valve can be connected, not both.")
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()
    clm()
end
if (bridgeSide) then
   bridge["peripheral"] = peripheral.wrap(bridgeSide)
   clb()
end

---------------------------------------
--the Main
---------------------------------------

rednet.open(modemSide)
if (#lstTanks > 0) 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)