tankmon for CC 1.57

--tankmon
--   Railcraft tank monitoring by Forgotten_Boy
--   	requires OpenPeripherals (OP) at least version 0.1.9, supports new liquid names in OP 0.2.1
-- 		with thanks to AmigaLink and Kalmor for the updated liquid names.
--   	Supports iron and steel Railcraft tanks and 15 common liquids.
--[[
 Setup:
 - Place an Advanced Computer with wireless modem and with tankmon on it adjacent to a tank valve.  Run "tankmon".
 - Setup another Advanced Computer with wireless modem and with tankmon on it adjacent to an advanced monitor.  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.

 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"};

----------------------------------------------------
-- 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.gray, "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"}
                }

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()
	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.getTanks("back")[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(tank["amount"]))
            rednet.send(serverID, textutils.serialize(info), false)
		end
		sleep(math.random(1,5))
    end
end

---------------------------------------
--the Main
---------------------------------------
local modemSide = "left";

if (peripheral.isPresent(modemSide) and (peripheral.getType(modemSide) == "modem")) then
    local modem = peripheral.wrap(modemSide)
else
    error("A wireless modem must be attached to the left of this computer.")
end

local tankSide = "top";
local tankSide2 = "top";
local screenSide = "right";

if ((peripheral.isPresent(tankSide) and (peripheral.getType(tankSide) == ("iron_tank_valve" or "steel_tank_valve"))) and (peripheral.isPresent(screenSide) and peripheral.getType(screenSide) == "monitor")) then
    error("Either a screen or a tank valve can be connected, not both.")
end

if (peripheral.isPresent(tankSide) and (peripheral.getType(tankSide) == ("iron_tank_valve" or "steel_tank_valve"))) then
    valve = peripheral.wrap(tankSide)
elseif (peripheral.isPresent(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()
else
	error("Either a screen or a tank valve must be connected. valve on top, screen on right")
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)