-- TurbineMonitor
--  Made By: MrKMG <mrkmg.com>
--
-- This program will keep your turbines up to speed
-- and turn the coil on and off as needed.
--
-- To Use:
--
-- Attach as many Turbines and Monitors as you
-- would like via wired modems. Monitors will all
-- display the same information for each turbine:
--    Current Speed
--    Current Power Generation,
--    Coil On/Off
--    Flow On/Off
--
-- Monitors can be of any size
--

--Edit these to fit your turbines

-- Speed to keep rotors between. Recommend putting
-- just above the best your turbine can do.
minSpeed = 1800
maxSpeed = 1820

-- Range of RF to keep in turbine. Recommend to
-- keep low to avoid waste.
minEnergy = 1
maxEnergy = 200000

-- Colors for the monitor
uiColors = {}
uiColors["background"] = colors.gray
uiColors["border"] = colors.black
uiColors["headerBackground"] = colors.blue
uiColors["headerText"] = colors.black
uiColors["currentSpeedBackground"] = colors.black
uiColors["currentSpeedText"] = colors.white
uiColors["currentPowerGenBackground"] = colors.black
uiColors["currentPowerGenText"] = colors.white
uiColors["coilOnBackground"] = colors.green
uiColors["coilOnText"] = colors.white
uiColors["coilOffBackground"] = colors.red
uiColors["coilOffText"] = colors.white
uiColors["flowOnBackground"] = colors.green
uiColors["flowOnText"] = colors.white
uiColors["flowOffBackground"] = colors.red
uiColors["flowOffText"] = colors.white

-- Text for the monitor.
uiText = {}
uiText["name"] = "Turbine "
uiText["rpm"] = " rpm"
uiText["rft"] = " RF/t"
uiText["rfs"] = " RF/s"
uiText["/"] = " / "
uiText["flowOn"] = "Flow: On"
uiText["flowOff"] = "Flow: Off"
uiText["coilsOn"] = "Coils: On"
uiText["coilsOff"] = "Coils: Off"
uiText["title"] = "Turbine Monitor"



-- Edit below at your your own risk
-- !#!#!#!#!#!#!#!#!#!#!#!#!#!#!#!#

function drawPixel(x, y, col)
	mon.setTextColor(uiColors["coilOnText"])
	mon.setCursorPos(x, y)
	mon.setBackgroundColor(col)
	mon.write(" ")
end

function drawLine(x, y, length, col)
	for i = 0, length - 1 do
		drawPixel(x + i, y, col)
	end
end

-- Center Text
local function printCenter(mon, y, txt)
	local w, h = mon.getSize()
	local x = math.floor((w / 2) - (#txt / 2))

	mon.setBackgroundColor(uiColors["flowOffBackground"])
	mon.setTextColor(uiColors["coilOnText"])
	mon.setCursorPos(x, y)
	mon.write(txt)
end

-- Global Variables
mon = peripheral.wrap("right")

t = {} -- Holds turbines
m = {} -- Holds monitor
w = {} -- Holds windows

-- Other Functions

function round(num)
    return math.floor(num + 0.5)
end

-- Program Functions

-- Finds all devices. Puts turbines in `t` table
-- and monitors in `m` table
function getDevices()
    for _, name in pairs(peripheral.getNames()) do
        if peripheral.getType(name) == "BigReactors-Turbine" then
            table.insert(t, peripheral.wrap(name))
        end
        if peripheral.getType(name) == "monitor" then
            table.insert(m, peripheral.wrap(name))
        end
    end
end

-- Determines if the coil should be turned on
function needCoilOn(i)
    if t[i].getEnergyStored() < minEnergy then
        return true
    else
        return false
    end
end

-- Determines if the coil should be turned off
function needCoilOff(i)
    if t[i].getEnergyStored() > maxEnergy then
        return true
    else
        return false
    end
end

-- Turns coil on
function coilOn(i)
    t[i].setInductorEngaged(true)
end

-- Tuns coil off
function coilOff(i)
    t[i].setInductorEngaged(false)
end

-- Checks if coil in on or off
function isCoilOn(i)
    return t[i].getInductorEngaged()
end

-- Determines if flow should turn on
function needFlowOn(i)
    if t[i].getRotorSpeed() < minSpeed then
        return true
    else
        return false
    end
end

-- Determines if flow should turn off
function needFlowOff(i)
    if t[i].getRotorSpeed() > maxSpeed then
        return true
    else
        return false
    end
end

-- Turns flow on
-- (Sets flow to MAX)
function flowOn(i)
    t[i].setFluidFlowRateMax(t[i].getFluidFlowRateMaxMax())
end

-- Turns flow off
-- (Sets flow to 0)
function flowOff(i)
    t[i].setFluidFlowRateMax(0)
end

-- Checks if flow is on or off
-- (Assumes MAX is on, other is off)
function isFlowOn(i)
    return t[i].getFluidFlowRateMax() == t[i].getFluidFlowRateMaxMax()
end

-- Get Rotor Speed
function getRotorSpeed(i)
    return math.floor(t[i].getRotorSpeed())
end

-- Get Power Generation
function getPowerGeneration(i)
    return math.floor(t[i].getEnergyProducedLastTick())
end

-- Get Sum Power Generation
function getSumPowerGeneration()
    local sum = 0
	for i = 1, #t ,1 do
		sum = sum + getPowerGeneration(i)
	end
	return sum
end

function getSumPowerGeneration20()
    local sum = 0
	for i = 1, #t ,1 do
		sum = getSumPowerGeneration() * 20
	end
	return sum
end

-- Returns text scale for best fit
-- TODO Figure out if there is a better way than
-- brute forcing
function getScaleForBox(baseWidth, baseHeight, fitWidth, fitHeight, count)
    local best = 0.5

    for i = best, 5, 0.5 do
        local cWidth = baseWidth / i
        local cHeight = baseHeight / i

        local cPerRow = math.floor(cWidth / fitWidth)
        local cPerCol = math.floor(cHeight / fitHeight)

        if cPerRow * cPerCol >= count then
            best = i
        else
            break
        end
    end

    return best
end

-- Determins offset to center the windows in the
-- monitor.
function getOffsetForWindow(monitorWidth, monitorHeight, desiredWidth, desiredHeight, count)
    local columnsNeeded = math.min(math.floor(monitorWidth / desiredWidth), count)
    local rowsNeeded = math.ceil(count / columnsNeeded)

    local widthUsed = desiredWidth * columnsNeeded
    local heightUsed = desiredHeight * rowsNeeded

    local offsetLeft = math.ceil((monitorWidth - widthUsed) / 2)
    local offsetRight = math.ceil((monitorHeight - heightUsed) / 2)

    return offsetLeft, offsetRight
end

-- Clears each connected monitor
function clearMonitors()
    for i = 1, #m do
        m[i].setBackgroundColor(uiColors["border"])
        m[i].clear()
    end
end

-- Setup each monitor
-- (Put a window in each monitor for each turbine)
function setupMonitors()
    if #t > 0 then
        local monitorWidth
        local monitorHeight
        local desiredW = 14
        local desiredH = 8
        local currentX
        local currentY

        for i = 1, #m do
            print("Setting Up " .. i)

            table.insert(w, {})

            m[i].setTextScale(1)
            monitorWidth, monitorHeight = m[i].getSize()

            print("Initial Size: " .. monitorWidth .. " " .. monitorHeight)

            scale = getScaleForBox(monitorWidth, monitorHeight, desiredW, desiredH, #t)

            print("Scale: " .. scale)

            m[i].setTextScale(scale)
            monitorWidth, monitorHeight = m[i].getSize()

            offsetX, offsetY = getOffsetForWindow(monitorWidth, monitorHeight, desiredW, desiredH, #t)

            print("Offset: " .. offsetX .. " " .. offsetY)

            currentX = offsetX
            currentY = offsetY

            for ii = 1, #t do
                print(currentX .. " " .. currentY .. " " .. desiredW .. " " .. desiredH)
                table.insert(w[i], window.create(m[i], currentX, currentY, desiredW, desiredH))

                currentX = currentX + desiredW
                if (currentX + desiredW > monitorWidth) then
                    currentX = offsetX
                    currentY = currentY + desiredH
                end
            end
        end
    end
end

-- Write status of turn to window
function writeStatus(turbine, screen)
    screen.setBackgroundColor(uiColors["border"])
    screen.clear()

    -- Write Title
    screen.setBackgroundColor(uiColors["headerBackground"])
    screen.setTextColor(uiColors["headerText"])
    screen.setCursorPos(2, 2)
    screen.clearLine()
    screen.write(uiText["name"] .. turbine)

    --Filler
    screen.setBackgroundColor(uiColors["background"])
    screen.setCursorPos(1, 3)
    screen.clearLine()

    -- Write Rotor Speed
    screen.setBackgroundColor(uiColors["currentSpeedBackground"])
    screen.setTextColor(uiColors["currentSpeedText"])
    screen.setCursorPos(2, 4)
    screen.clearLine()
    screen.write(getRotorSpeed(turbine) .. uiText["rpm"])

    -- Write Power Generation
    screen.setBackgroundColor(uiColors["currentPowerGenBackground"])
    screen.setTextColor(uiColors["currentPowerGenText"])
    screen.setCursorPos(2, 5)
    screen.clearLine()
    screen.write(getPowerGeneration(turbine) .. uiText["rft"])

    --Filler
    screen.setBackgroundColor(uiColors["background"])
    screen.setCursorPos(1, 6)
    screen.clearLine()
	
    -- Write Coil Status
    if isCoilOn(turbine) then
        screen.setBackgroundColor(uiColors["coilOnBackground"])
        screen.setTextColor(uiColors["coilOnText"])
        screen.setCursorPos(2, 7)
        screen.clearLine()
        screen.write(uiText["coilsOn"])
    else
        screen.setBackgroundColor(uiColors["coilOffBackground"])
        screen.setTextColor(uiColors["coilOffText"])
        screen.setCursorPos(2, 7)
        screen.clearLine()
        screen.write(uiText["coilsOff"])
    end

    -- Write Flow Status
    if isFlowOn(turbine) then
        screen.setBackgroundColor(uiColors["flowOnBackground"])
        screen.setTextColor(uiColors["flowOnText"])
        screen.setCursorPos(2, 8)
        screen.clearLine()
        screen.write(uiText["flowOn"])
    else
        screen.setBackgroundColor(uiColors["flowOffBackground"])
        screen.setTextColor(uiColors["flowOffText"])
        screen.setCursorPos(2, 8)
        screen.clearLine()
        screen.write(uiText["flowOff"])
    end

    -- Draw Right Border
    screen.setBackgroundColor(uiColors["border"])
    for i = 1, 8 do
        screen.setCursorPos(14, i)
        screen.write(" ")
    end
	
end

-- Write status of each turbine to appropiate windows
function writeStatuses()
    for i = 1, #m do
        for ii = 1, #t do
            writeStatus(ii, w[i][ii])
        end
    end
end

-- Setup
function setup()
    w = {}
    m = {}
    t = {}

    getDevices()

    if (#t == 0) then
        error("No Turbines. You did something wrong")
    end

    if (#m > 0) then
        clearMonitors()
        setupMonitors()
    end
end

-- Main Loop
function main()
    for i = 1, #t do
        if isCoilOn(i) then
            if needCoilOff(i) then
                print("turning off " .. i)
                coilOff(i)
            end
        else
            if needCoilOn(i) then
                print("turning on " .. i)
                coilOn(i)
            end
        end
        if isFlowOn(i) then
            if needFlowOff(i) then
                print("stopping flow " .. i)
                flowOff(i)
            end
        else
            if needFlowOn(i) then
                print("starting flow " .. i)
                flowOn(i)
            end
        end
    end
    writeStatuses()
end

-- Program Run
setup()
while true do
    main()
	
	drawLine(1, 2, 4, colors.black)
	drawLine(5, 2, 69, colors.red)
	drawLine(74, 2, 6, colors.black)
	
	drawLine(1, 3, 4, colors.black)
	drawLine(5, 3, 69, colors.red)
	printCenter(mon, 3, uiText["title"])
	drawLine(74, 3, 6, colors.black)
	
	drawLine(1, 4, 4, colors.black)
	drawLine(5, 4, 69, colors.red)
	drawLine(74, 4, 6, colors.black)
	
	drawLine(1, 48, 4, colors.black)
	drawLine(5, 48, 69, colors.red)
	drawLine(74, 48, 6, colors.black)
	
	drawLine(1, 49, 4, colors.black)
	drawLine(5, 49, 69, colors.red)
	printCenter(mon, 49, getSumPowerGeneration() .. uiText["rft"] .. uiText["/"] .. getSumPowerGeneration20() .. uiText["rfs"])
	drawLine(74, 49, 6, colors.black)
	
	drawLine(1, 50, 4, colors.black)
	drawLine(5, 50, 69, colors.red)
	drawLine(74, 50, 6, colors.black)
	
    os.sleep(1)
end