local fs = require("filesystem")
local term = require("term")
local computer = require("computer")
local keyboard = require("keyboard")
local event = require("event")
local gpu = require("component").gpu
local serialization = require("serialization")
local logger = {}

function logger:init(program)
  self.loggerFolder = "/var/" .. program .. "/"
  local logNumber = 0
  local found = false
  while not found do
    if (fs.exists(self.loggerFolder .. "log-" .. logNumber .. ".log")) then
      logNumber = logNumber + 1
    else
      self.logNumber = logNumber
      found = true
    end
  end
  self.initTime = os.time()
end

function logger:ensurelogFolderExists()
  if not fs.exists(self.loggerFolder) then
    fs.makeDirectory(self.loggerFolder)
  end
end

function logger:log(message)
  self:ensurelogFolderExists()
  local file = io.open(self.loggerFolder.."log-"..self.logNumber..".log","a")
  file:write("["..string.format("%07d",(os.time()-self.initTime)).."]"..message.."\n")
  file:close()
end

local versionNum = 0
local versionName = "0.0"

logger:init("blockio")

logger:log("Launching Block.io")
logger:log("Version "..versionName.." ("..versionNum..")")

if not term.isAvailable() then
  logger:log("Term is not avalible.")
  return
end

blockio = {}

local core = {}
local currentTab = 0
local tabs = {}
local packages = {}
local loadingProgress = 0

function core.prePreInitCore()
  logger:log("Pre Pre Initializing core")
  logger:log("Free memory: " .. computer.freeMemory())
  gpu.setBackground(0xFFFFFF)
  gpu.setForeground(0x000000)
  local w , h = gpu.getResolution()
  gpu.fill(1,1,w,h," ")
  gpu.set(w/2 - 4, h/2, "BLOCK.IO")
  gpu.setBackground(0x000000)
  gpu.setForeground(0xFFFFFF)
  core.updateLoadingScreen(4.15)

  function blockio.log(message)
    logger:log(message)
  end

  function blockio.isPackageInstalled(packageName)
    checkArg(1,packageName,"string")
    return packages[packageName] ~= nil
  end

  function blockio.getPackageList()
    local keyset={}
    local n=0

    for k,v in pairs(tab) do
      n=n+1
      keyset[n]=k
    end

    return keyset
  end
  core.updateLoadingScreen(4.15)
end

function core.preInitCore()
  logger:log("Pre Initializing core")
  logger:log("Free memory: " .. computer.freeMemory())

  core.updateLoadingScreen(4.15)
  core.updateLoadingScreen(4.15)
end

function core.postInitCore()
  logger:log("Post Initializing core")
  logger:log("Free memory: " .. computer.freeMemory())
  function blockio.addTab(tab)
    checkArg(1,tab,"table")
    core.addTab(tab)
  end
  function blockio.switchToTab(tab)
    checkArg(1,tab,"number")
    core.switchToTab(tab)
  end
  core.updateLoadingScreen(4.15)
  core.updateLoadingScreen(4.15)
end

function core.postPostInitCore()
  logger:log("Post Post Initializing core")
  logger:log("Free memory: " .. computer.freeMemory())
  function blockio.quit()
    logger:log("blockio.quit called.")
    core.softExit()
  end
  core.updateLoadingScreen(4.15)
  core.updateLoadingScreen(4.15)
end

function core.updateLoadingScreen(progress)
  loadingProgress = loadingProgress + progress
  local w , h = gpu.getResolution()
  gpu.setBackground(0x000000)
  gpu.setForeground(0xFFFFFF)
  gpu.set(w/2 - 5, h/2 + 1, string.format("%02d",loadingProgress).."% Loaded")
end

function core.addTab(tab)
  logger:log("Adding new tab.")
  local foundUID = false
  local UID = 0
  while not foundUID do
    UID = math.random(0xFFFFFFFF)
    foundUID =  tabs[UID] == nil
  end

  logger:log("New tab UID is "..UID)

  tabs[UID] = tab
  tabs[UID].UID = UID
  if(tabs[UID]["init"]~= nil) then
    logger:log("init found in new tab , calling")
    local status, err = pcall(tabs[UID].init,tabs[UID])

    if(status) then
      logger:log("init successful")
    else
      logger:log("init error: ")
      logger:log(serialization.serialize(err))
    end
  end
end

function core.switchToTab(tab)
  logger:log("Switching from tab "..currentTab.." to tab "..tab)

  if tabs[tab] ~= nil then
  error("There is no tab with UID "..tab)
  end

  if tabs[currentTab] ~= nil then
    if(tabs[currentTab]["leaveTab"]~= nil) then
      logger:log("leaveTab found in old tab , calling")
      local status, err = pcall(tabs[currentTab].leaveTab,tabs[currentTab])
      if status then
        logger:log("leaveTab successful")
      else
        logger:log("leaveTab error: ")
        logger:log(serialization.serialize(err))
      end
    end
  end

  if tabs[tab]["enterTab"]~= nil then
    logger:log("enterTab found in new tab , calling")
    local status, err = pcall(tabs[tab].enterTab,tabs[tab])

    if status then
      logger:log("enterTab successful")
    else
      logger:log("enterTab error: ")
      logger:log(serialization.serialize(err))
    end
  end
  currentTab = tab
end

function core.loadPackages()
  logger:log("Loading Packages")
  logger:log("Loading Packages into memoery")
  if not fs.exists("/etc/blockio/") then
    fs.makeDirectory("/etc/blockio/")
  end
  local packageFiles = fs.list("/etc/blockio/")
  local numberOfFiles = 0
  for packageFile in packageFiles do
    numberOfFiles = numberOfFiles + 1;
  end
  packageFiles = fs.list("/etc/blockio/")
  local numberOfPackages = 0
  for packageFile in packageFiles do
    local path,name,extension = string.match(packageFile, "(.-)([^/]-([^/%.]+))$")
    name = string.gsub(name,".lua","")
    fileLoc = "/etc/blockio/"..name.."."..extension

    logger:log("Found package :"..packageFile)

    if(extension == "lua") then
      logger:log(name.." is lua , loading into packages")
      packages[name] = dofile(fileLoc)
      numberOfPackages = numberOfPackages + 1
    end
    core.updateLoadingScreen(16.6/numberOfFiles)
  end

  for packageName,table in pairs(packages) do
    for values , func in pairs(table) do
        logger:log(packageName.." contains ".. values)
    end
  end

  for packageName,table in pairs(packages) do
      local loadingPerStep = 16.6/numberOfPackages
      logger:log("Pre initializing "..packageName)
      table.name = packageName;
      if table["preInit"]~= nil then
        local status, err = pcall(table.preInit,table,loadingPerStep)
        if status then
          logger:log(packageName.."preInit successful")
        else
          logger:log("preInit error: ")
          logger:log(serialization.serialize(err))
        end
      else
        logger:log("Pre init not found.")
      end

      core.updateLoadingScreen(loadingPerStep)
  end
  core.preInitCore()
  for packageName,table in pairs(packages) do
      local loadingPerStep = 16.6/numberOfPackages
      logger:log("Initializing "..packageName)
      if(table["init"] ~= nil) then
        pcall(table.init,table,loadingPerStep)
      else
        logger:log("Init not found.")
      end

      core.updateLoadingScreen(loadingPerStep)
  end
  core.postInitCore()
  for packageName,table in pairs(packages) do
      local loadingPerStep = 16.6/numberOfPackages
      logger:log("Post initializing "..packageName)
      if(table["postInit"] ~= nil) then
        pcall(table.postInit,table,loadingPerStep)
      else
        logger:log("Post init not found.")
      end
      core.updateLoadingScreen(loadingPerStep)
  end
end

core.exit = false;
function core.softExit()
  logger:log("softExit called.")
  core.exit = true
end

function core.hardExit()
  logger:log("hardExit called.")
  logger:log("Forcing exit with os.exit().")
  os.exit()
end

function core.onKeyDown(char, code)
  if keyboard.pressedCodes[code] == nil then
    table.insert(keyboard.pressedCodes,code)
    table.insert(keyboard.pressedChars,char)
  end
  if keyboard.isControlDown() and code == keyboard.keys.q then
    core.softExit()
  end
end

function core.onKeyUp(char, code)
  if keyboard.pressedCodes[code] ~= nil then
    table.remove(keyboard.pressedCodes,code)
    table.remove(keyboard.pressedChars,char)
  end
end

function core.main()
  core.prePreInitCore()
  core.loadPackages()
  core.postPostInitCore()

  logger:log("Entering Main Loop")
  while not core.exit do
    local event, address, arg1, arg2, arg3 = event.pull()
    if event == "key_down" then
      core.onKeyDown(arg1, arg2)
    elseif event == "key_up" then
      core.onKeyUp(arg1, arg2)
    end
  end
  logger:log("Left main loop")
end

logger:log("Entering Main")
local status, err = pcall(core.main)
if status then
  logger:log("Block.io exited with no errors. See you next time!")
else
  logger:log("Block.io exited with the following error: ")
  logger:log(serialization.serialize(err))
end