--PowergraphMulti is made by Stekeblad 11/2017

  ------------- Configuration part ------------------

  -- Seconds between checking stored energy
  -- and updating monitors (default: 5)
  local updateInterval = 5

  -- Simple mode tries to scan for compatible storages and
  -- wrap the first found one and the first found monitor
  -- For more advanced configuration, set this to false and
  -- and fill the dataTable below (example follows)
  -- Default: true
  local simpleMode = false

  local dataTable = {
    {
        monitor = "top",
        energy = "back",
        textSize = 0.5
     }
  }

    -- help for how to fill dataTable:
  --[[ add a comma at the end of all lines except the
    last one in all tables.
    "[required]" in front of a line means you need to
    have it or the program won't work, rows with
    "[optional]" are optional and can be left out.
    The following information can be added:

    [required] monitor = the side or network name
              of a monitor connected to the computer.
    [required] energy = the energy storage witch
              content should be displayed on the
              monitor defined above.
    [optional] text = a word or sentence that will
              be displayed at the bottom line on the
              monitor.
    [optional] blitColor = Will be ignored if its
              not a advanced monitor, specifies the
              color of the graph, see following link
              for help:
              http://www.computercraft.info/wiki/Colors_(API)#Colors
              allowed values are 0-9 and a-f,
              defaults to 5 (green)
    [optional] textSize = Sets how large the text is and
              how thick the graph line is.
              Needs to be between 0.5 and 5 and is in
              steps of 0.5. eg 0.5, 1, 1.5 ... 4.5, 5
              Default is 1. (5 is very large text)

  local Example = {
    {
      monitor = "monitor_1",    <-- comma
      energy = "tile_blockcapacitorbank_name_0", <--comma
      text = "ME Backup",     <-- comma
      blitColor = "5"       <-- no comma, last line for this monitor-battery pair
      },{         <-- comma between braces, there are more monitor-battery pairs
      monitor = "top",      <-- comma
      energy = "back",      <-- comma
      textSize = 0.5    <-- no comma, last line in this pair
      }       <-- no comma, this was last pair
    }         <-- closing the example table, no comma

    ]] -- (ignore this two brackets, they indicate
       -- the end of this long multi-line comment)

  ------------- End of configuration part --------------------

  -- Dont change anything below this line
  -- if you not know what you are doing!

  if simpleMode then
    dataTable.auto = {}

    -- Scan after a monitor and wrap the first one found
    -- If no monitor is found, error and exit
    local mon = peripheral.find("monitor")
    if not mon then
      error("Could not automaticly find a monitor, connect one with a wired modem or place one touching the computer")
    else
      dataTable.auto.monitor = mon
    end

    -- Scan for energy storage, first EnderIO
    local ene = peripheral.find("tile_blockcapacitorbank_name") -- basic, normal and vibrant

    -- If not found, scan for thermal expansion cells
    if not ene then
      ene = peripheral.find("tile_thermalexpansion_cell_basic_name")
    end

    -- ImmersiveEngineering
    if not ene then
      ene = peripheral.find("IE:lvCapacitor")
    end
    if not ene then
      ene = peripheral.find("IE:mvCapacitor")
    end
    if not ene then
      ene = peripheral.find("IE:hvCapacitor")
    end

    -- Draconic Evolution
    if not ene then
      ene = peripheral.find("draconic_rf_storage")
    end

    -- Industrial Craft 2
    if not ene then
      ene = peripheral.find("batbox")
    end
    if not ene then
      ene = peripheral.find("mfe")
    end
    if not ene then
      ene = peripheral.find("mfsu")
    end

    -- Tech reborn
    if not ene then
      ene = peripheral.find("techreborn:low_voltage_su")
    end
    if not ene then
      ene = peripheral.find("techreborn:medium_voltage_su")
    end
    if not ene then
      ene = peripheral.find("techreborn:high_voltage_su")
    end


    -- Mekanism
    if not ene then
      ene = peripheral.find("Basic Energy Cube")
    end
    if not ene then
      ene = peripheral.find("Advanced Energy Cube")
    end
    if not ene then
      ene = peripheral.find("Elite Energy Cube")
    end
    if not ene then
      ene = peripheral.find("Ultimate Energy Cube")
    end
    if not ene then
      ene = peripheral.find("Induction Matrix")
    end

    -- Big Reactors
    if not ene then
      ene = peripheral.find("BigReactors-Reactor")
    end
    if not ene then
      ene = peripheral.find("BigReactors-Turbine")
    end

    -- plethora (peripheral)
    if not ene then
      local periphs = peripheral.getNames()
      for _, v in pairs(periphs) do
        local periph = peripheral.wrap(v)
        if (periph.getMetadata and periph.getMetadata().energy
        and periph.getMetadata().energy.capacity
        and periph.getMetadata().energy.stored) then
          ene = periph
          break
        end
      end
    end

    -- End of scanning attempts
    if ene then
      dataTable.auto.energy = ene
    else
      print("Could not automaticly find a energy storage, check the connection or try adding it in the program code in dataTable and disable simpleMode")
      print("Connected peritherals: ")
      local periphs = peripheral.getNames()
      for _, v in pairs(periphs) do
        print(v)
      end
      error("Fix the above and try again")
    end
  end


  local emptyDataTable = true

  -- checks information in dataTable and sets variables
  -- that will be used later
  for rowNumber, row in pairs(dataTable) do
    emptyDataTable = false
    local monTest
    if type(row.monitor) == "table" then monTest = row.monitor -- true if on simpleMode
    else monTest = peripheral.wrap(row.monitor) end

    -- Monitor stuff
    if (monTest == nil) then
      error("\nCould not wrap monitor on row " .. rowNumber)
    end
    row.monitor = monTest

    local test = row.monitor.isColor()
    if (test == nil) then
      error("\n\"monitor\" on row " .. rowNumber .. " is not a monitor")
    end
    row.monIsColor = test

    if row.textSize then
      local size = row.textSize*2
      if size < 1 or size > 10 or size ~= math.floor(size) then
        if row.monIsColor then term.setTextColor(colors.yellow) end
        print("\nInvalid textSize for monitor on row " .. rowNumber .. ". Needs to be beween 0.5 and 5 and a multiple of 0.5")
        print("Using monitor default 1")
        if row.monIsColor then term.setTextColor(colors.white) end
      else
        row.monitor.setTextScale(row.textSize)
      end
    end

    if (row.text ~= nil) then row.hasText = 1
    else row.hasText = 0 end

    row.x, row.y = row.monitor.getSize()
    row.Y = 100/(row.y - 1 - row.hasText)
    row.pointsArray = {}
    row.indexPointer = 1
    for i = 1, row.x do
      row.pointsArray[i] = row.y - row.hasText --looks like 0% in the beginning
    end

    if not row.blitColor then row.blitColor = "5"
    else
      local bc = row.blitColor
      if not (bc == "0" or bc == "1" or bc == "2" or bc == "3"
      or bc == "4" or bc == "5" or bc == "6" or bc == "7"
      or bc == "8" or bc == "9" or bc == "a" or bc == "b"
      or bc == "c" or bc == "d" or bc == "e" or bc == "f") then
        if row.monIsColor then term.setTextColor(colors.yellow) end
        print("\nInvalid blitColor for monitor on row " .. rowNumber .. ". Needs to be in quotation marks and between 0-9 or a-f")
        print("Defaulting to green (5)")
        if row.monIsColor then term.setTextColor(colors.white) end
        row.blitColor = "5"
      end
    end

    if row.x < 27 then row.hideStekeblad = true -- do not print "Stekeblad's Powergraph" if it
    else row.hideStekeblad = false end          -- does not fit on the monitor
    if ((row.hasText == 1) and (row.x < string.len(row.text))) then
      if row.monIsColor then term.setTextColor(colors.yellow) end
      print("\nDefined text for monitor on row " .. rowNumber .. " does not fit on screen")
      if row.monIsColor then term.setTextColor(colors.white) end
    end

    --  Battery stuff
    local eneTest
    if type(row.energy) == "table" then eneTest = row.energy
    else eneTest = peripheral.wrap(row.energy) end

    if (eneTest == nil) then
      error("\nCould not wrap energy storage on row " .. rowNumber)
    else
      row.energy = eneTest
      -- check if IC2 energy storage and if so add support for it
      if (row.energy.getEUStored and row.energy.getEUCapacity) then
        row.energy.getEnergyStored = row.energy.getEUStored
        row.energy.getMaxEnergyStored = row.energy.getEUCapacity

      -- check if mekanism energy storage and if so add support for it
      elseif (row.energy.getEnergy and row.energy.getMaxEnergy) then
        row.energy.getEnergyStored = row.energy.getEnergy
        row.energy.getMaxEnergyStored = row.energy.getMaxEnergy

      -- check if bigreactors reactor (can store 10 million)
      elseif (row.energy.getEnergyStored and row.energy.getControlRodLevel) then
        row.energy.getMaxEnergyStored = function() return 10000000 end

      -- check for bigreactors turbine (can store 1 million)
      elseif (row.energy.getEnergyStored and row.energy.getBladeEfficiency) then
        row.energy.getMaxEnergyStored = function() return 1000000 end

      -- plethora (peripheral)
      elseif (row.energy.getMetadata) then
          local blockMeta = row.energy.getMetadata()
          if (blockMeta.energy and blockMeta.energy.stored and blockMeta.energy.capacity) then
              row.energy.getEnergyStored = function() return row.energy.getMetadata().energy.stored end
              row.energy.getMaxEnergyStored = function() return row.energy.getMetadata().energy.capacity end
          end

      -- If the energy storage is not compatible
      elseif not (row.energy.getEnergyStored and row.energy.getMaxEnergyStored) then
        error("\n\"energy\" on row " .. rowNumber .. " is not a energy storage or does not support the required functions")
      end
      row.maxEnergy = row.energy.getMaxEnergyStored()
    end
  end

    -- Check if dataTable is empty and tell user to add something
  if emptyDataTable then
    if term.isColor then term.setTextColor(colors.red) end
    print("\nNo monitors and energy storages added, press enter to open file for editing....")
    if term.isColor then term.setTextColor(colors.white) end
    read()
    shell.run("edit " .. shell.getRunningProgram())
    return -1
  end

  print("\nSuccessfully wrapped all monitors and energy storages as peripherals")

  -- Prints one pixel of the graph in choosen color, or white if non-advanced
  function blitPoint(row)
    if row.monIsColor then
      row.monitor.blit(row.blitColor, row.blitColor, row.blitColor) -- (advanced monitor)
    else
      row.monitor.blit("0", "0", "0") -- Write a white 0 on a white background (normal monitor)
    end
  end

  -- Prints the "text"-value for the storage centered at the bottom, if defined
  function printBottomText(row)
    if row.hasText == 1 then
      local strLen = string.len(row.text)
      row.monitor.setCursorPos((row.x-strLen+1)/2, row.y)
      row.monitor.write(row.text)
    end
  end

  -- Prints "Stekeblad's Powergraph" centered at the top of the monitor, if their is enough space
  function printMadeBy(row)
    if row.hideStekeblad == false then
      local startX = math.floor(row.x/2-13)
      row.monitor.setCursorPos(startX, 1)
      row.monitor.write("Stekeblad's Powergraph")
    end
  end

  -- Print how many percent of the storage is full
  function printPercentFull(row)
    row.monitor.setCursorPos(row.x-4, 1)
    row.monitor.write(row.filledPercent .. "%")
  end

  local all = {} -- Creates a table for functions that will operate on all monitor-battery pairs

  -- Read from storage and find the y-value of this point
  all.getNewData = function ()
    for rowNumber, row in pairs(dataTable) do
      local stored = row.energy.getEnergyStored()
      if stored == nil then
        error("\n Failed to read stored energy from storage on row " .. rowNumber)
      end
      row.filledPercent = math.floor((stored/row.maxEnergy)*100)
      local pointY = math.floor(row.filledPercent/row.Y)
      if pointY == row.y - 1 - row.hasText then pointY = pointY-1 end
      row.pointsArray[row.indexPointer] = row.y - pointY - row.hasText--Else is 100% bottom of screen and top is 0%
      row.indexPointer = (row.indexPointer % row.x) + 1
    end
  end

  -- Refreshes what you see on the monitors
  all.updateView = function ()
    for rowNumber, row in pairs(dataTable) do
      local ptr = row.indexPointer
      local Xi = 1
      row.monitor.clear()
      printPercentFull(row)
      printMadeBy(row)
      if row.hasText then printBottomText(row) end
      row.monitor.setCursorPos(Xi, row.pointsArray[ptr])
      blitPoint(row) -- blit one character, based on if its a advanced or normal monitor
      Xi = (Xi % row.x) + 1
      ptr = (ptr % row.x) + 1
      while (ptr ~= row.indexPointer) do
        row.monitor.setCursorPos(Xi, row.pointsArray[ptr])
        blitPoint(row)
        Xi = (Xi % row.x) + 1
        ptr = (ptr % row.x) + 1
      end
    end
  end

  --Main program loop
  while true do
    all.getNewData()
    all.updateView()
    sleep(updateInterval)
  end