local component = require ("component")
local computer  = require ("computer")
local term      = require ("term")

local gpu = component.gpu

local device
local redstone

------------------------------

local running              = true
local tickrate             = 20
local timeout              = 1
local fatal_energy         = 20
local energy_unit          = "RF"
local energy_device_name   = "energy_device"
local max_energy_func_name = "getMaxEnergyStored"
local     energy_func_name = "getEnergyStored"
local energy_on_limit      = 70
local energy_off_limit     = 80
local redstone_side        = 1
local redstone_inverted    = true

local res_x, res_y = 32, 16

local background        = 0x121212
local foreground        = 0xffffff
local lost_energy_color = 0xff0000
local got_energy_color  = 0x00ff00
local wait_energy_color = 0xffff00
local energy_bar_color  = 0x006fff

local max_energy

local last_beeped = false

-----------------------------

local function getEnergy ()

  if not device[energy_func_name] then

    error ("Get energy function '" .. energy_device_name .. "." .. energy_func_name .. "' not found")

  end

  return device[energy_func_name] ()

end

------------------------------

local function getMaxEnergy ()

  if not device[max_energy_func_name] then

    error ("Get max energy function '" .. device_name .. "." .. max_energy_func_name .. "' not fund")

  end

  return device[max_energy_func_name] ()

end

------------------------------

local function init ()

  if component.isAvailable (energy_device_name) then

    device = component.energy_device
    max_energy = getMaxEnergy ()

  else

    error ("Energy device '" .. energy_device_name .. "' is unavailable")

  end

  if component.isAvailable ("redstone") then

    redstone = component.redstone

  end

end

------------------------------

local function setPower (power)

  if not redstone then return end

  if redstone_inverted then power = not power end

  if power then

    redstone.setOutput (redstone_side, 15)

  else

    redstone.setOutput (redstone_side, 0)

  end

end

------------------------------

local function drawEnergyStored (stored)

  local width = res_x / max_energy * stored

  gpu.setBackground (background)
  gpu.fill (1, res_y, res_x, 2, " ")

  gpu.setBackground (energy_bar_color)
  gpu.fill (1, res_y, width, 1, " ")

end

------------------------------

local function beepIfNeed (stored, got)

  local percent = math.floor (100 / max_energy * stored)

  gpu.setForeground (foreground)

  if percent < fatal_energy and got < 0 then

    last_beeped = true

    for i = 1, 3 do computer.beep (1000, 0.01) end

    print (percent .. "% of energy left")
    print ("Please charge baterry")

   else

      if last_beeped then

        computer.beep (330, 0.01)
        computer.beep (450, 0.01)
        computer.beep (500, 0.01)

    end

    last_beeped = false

  end

end

------------------------------

local function main ()

  init ()

  while running do

    gpu.setBackground (background)

    local start_energy = getEnergy ()
    local start_time   = computer.uptime ()

    if computer.pullSignal (timeout) == "key_down" then

      running = false

    end

    local stored = getEnergy ()
    local time = computer.uptime () - start_time

    local recieved = (stored - start_energy) / time / tickrate
    recieved = math.floor (recieved * 100) / 100

    local str = tostring (recieved) .. " " .. energy_unit .. "/t"

    local percent = math.floor (100 / max_energy * stored)

    if percent > energy_off_limit then

      setPower (false)

    end

    if percent < energy_on_limit then

      setPower (true)

    end

    if recieved > 0 then

      str = "+" .. str .. " | " .. percent .. "% stored"
      gpu.setForeground (got_energy_color)

    else


      str = str .. " | " .. percent .. "% stored"
      gpu.setForeground (wait_energy_color)

    end

    if percent > energy_on_limit then

      gpu.setForeground (wait_energy_color)

    end

    print (str)

    beepIfNeed       (stored, recieved)
    drawEnergyStored (stored)

  end

end

------------------------------

local function errorHandler (error_message, traceback)

  return {message = error_message, traceback = debug.traceback ()}

end

------------------------------

do

  gpu.setResolution (res_x, res_y)

  gpu.setBackground (background)
  gpu.setForeground (foreground)

  term.clear ()

  print ("Press any key to exit")

  local runresult, err = xpcall (main, errorHandler)

  gpu.setResolution (gpu.maxResolution ())
  gpu.setBackground (0x000000)
  gpu.setForeground (0xffffff)

  term.clear ()

  function s () os.sleep (0.1) end

  if not runresult then

    computer.beep (500, 0.01)
    computer.beep (500, 0.01)

    print ("Runtime error:\n")
    s ()

    print ("|===============================|\n")

    gpu.setForeground (0xff0000)
    print (err.message .. "\n")
    s ()

    gpu.setForeground (0xffffff)
    print ("|===============================|\n")
    s ()

    gpu.setForeground (0x006fff)
    print (err.traceback .. "\n")
    s ()

    gpu.setForeground (0xffffff)
    print ("|===============================|\n")

  end

  gpu.setForeground (0xffffff)

end

------------------------------