--[[
Created By: Augur ShicKla
Special Thanks To: TRC & matousss
v0.8.16

System Requirements:
Tier 3.5 Memory
Tier 3 GPU
Tier 3 Screen
]]--

local Version = "0.8.16"
local component = require("component")
local computer = require("computer")
local event = require("event")
local os = require("os")
local term = require("term")
local thread = require("thread")
local serialization = require("serialization")
local unicode = require("unicode")
local filesystem = require("filesystem")
local sides = require("sides")
local screen = component.screen
local gpu = component.gpu
local modem = {}

-- Checking System Requirements are Met --------------------------------------------
if gpu.maxResolution() ~= 160 then
  io.stderr:write("Tier 3 GPU and Screen Required")
  os.exit(1)
end
if computer.totalMemory() < 1048576 then
  io.stderr:write("Not Enough Memory To Run. Please Install More Memory.")
  os.exit(1)
end
if not component.isAvailable("stargate") then
  io.stderr:write("No Stargate Connected.")
  os.exit(1)
end
NumberOfGates = 0
for k,v in component.list() do
  if v == "stargate" then NumberOfGates = NumberOfGates+1 end
end
if NumberOfGates > 1 then
  io.stderr:write("Too Many Stargates Connected to Computer.")
  os.exit(1)
end
-- End of Checking System Requirements ---------------------------------------------

-- Checking to see if AGS properly closed last time --------------------------------
if _G.agsProperlyClosed ~= nil and _G.agsProperlyClosed == false then
  io.stderr:write("AGS was not properly shut down last time, and the computer needs to be rebooted.")
  os.exit(1)
end
_G.agsProperlyClosed = false
-- End of Checking to see if AGS properly closed last time -------------------------

-- Declarations --------------------------------------------------------------------
local sg = component.stargate

local GlyphsMW = {"Andromeda","Aquarius","Aries","Auriga","Bootes","Cancer","Canis Minor","Capricornus","Centaurus","Cetus","Corona Australis","Crater","Equuleus","Eridanus","Gemini","Hydra","Leo","Leo Minor","Libra","Lynx","Microscopium","Monoceros","Norma","Orion","Pegasus","Perseus","Pisces","Piscis Austrinus","Sagittarius","Scorpius","Sculptor","Scutum","Serpens Caput","Sextans","Taurus","Triangulum","Virgo"}
local GlyphsPG = {"Aaxel","Abrin","Acjesis","Aldeni","Alura","Amiwill","Arami","Avoniv","Baselai","Bydo","Ca Po","Danami","Dawnre","Ecrumig","Elenami","Gilltin","Hacemill","Hamlinto","Illume","Laylox","Lenchan","Olavii","Once El","Poco Re","Ramnon","Recktic","Robandus","Roehi","Salma","Sandovi","Setas","Sibbron","Tahnan","Zamilloz","Zeo"}

GateType = ""
GateTypeName = ""
ConnectionErrorString = "Communication error with Stargate. Please disconnect and reconnect.\nIf problem persists verify AUNIS 1.9.6 or greater is installed, and replace Stargate base block."
local DatabaseFile = "gateEntries.ff"
local DatabaseFileBackup = "gateEntries.bak"
local configFile = "dialer.cfg"
gateEntries = {}
historyEntries = {}
AddressBuffer = {}
local keyCombo = {}
buttons = {}
ActiveButtons = {}
gateName = ""
addAddressMode = false
local GoodAddress = false
adrEntryType = ""
ComputerDialingInterlocked = false
local ComputerDialingWithDHD = false
editGateEntryMode = false
manualAdrEntryMode = false
isDirectDialing = false
AbortingDialing = false
WasCanceled = false
wasTerminated = false
MainLoop = true
HadNoError = true
ErrorMessage = nil
OutgoingWormhole = false
DialingInterlocked = false
DebugMode = false
RootDrive = nil
DialedAddress = {}
IncomingWormhole = false
GateStatusString, GateStatusBool = nil
local UNGateResetting = false
local DHD_AdrEntryMode = false
local freeMemoryPercent = ""
local infoExtensionMode = nil
local IrisType = nil
local IrisMetaType = nil
local DatabaseWriteTimer = nil
local IrisSettings = {IDC = nil, AutoCloseIris = true, ModemIDCPort = nil}
local IDC = nil
local ModemIDCPort = nil
local IrisDurability = ""
local OutgoingIDC = nil
local ChildThread = {}
local HasModem = false
local AdminList = {}
local User = ""
local AdminOnlySettings = {Quit = true, AddEntry = true, EditEntry = true, History = true, ToggleIris = true, AdminCanForceDialDHD = false}
local MiscSettings = {HideLocalAddr = false, dialWithDHD = false, LudicrousSpeed = false}
local HasRedstone = false
local RS_Settings = {ExhaustVentSide="north", ChevronEngagedSide="top", WormholeOpenSide="bottom", GateIsActiveSide="east"}
local AdminDialed = false
local ForceDialDHD = false
local DialingPaused = false
local WormholeConnected = false
-- End of Declarations -------------------------------------------------------------

-- Pre-Initialization --------------------------------------------------------------
if sg.getGateType() == "MILKYWAY" then
  GateType = "MW"
  GateTypeName = "Milky Way"
  if not pcall(function() sg.getEnergyRequiredToDial({GlyphsMW[1]}) end) then
    io.stderr:write("MW: "..ConnectionErrorString)
    os.exit(1)
  end
elseif sg.getGateType() == "UNIVERSE" then
  GateType = "UN"
  GateTypeName = "Universe"
  if not pcall(function() sg.getEnergyRequiredToDial({"G1"}) end) then
    io.stderr:write("UN: "..ConnectionErrorString)
    os.exit(1)
  end
elseif sg.getGateType() == "PEGASUS" then
  GateType = "PG"
  GateTypeName = "Pegasus"
  if not pcall(function() sg.getEnergyRequiredToDial({GlyphsPG[1]}) end) then
    io.stderr:write("PG: "..ConnectionErrorString)
    os.exit(1)
  end
else
  io.stderr:write("Gate Type Not Recognized")
  os.exit(1)
end

for k,v in filesystem.mounts() do -- Searches for the filesystem that holds root and assigns it to the RootDrive variable
  if v == "/" then
    RootDrive = k
  end
end

if component.isAvailable("modem") then
  HasModem = true
  modem = component.modem
end

if component.isAvailable("redstone") then
  HasRedstone = true
  redstone = component.redstone
  for i=0,5,1 do
    redstone.setOutput(i, 0)
  end
end
-- End of Pre-Initialization -------------------------------------------------------

-- Config File IO ------------------------------------------------------------------
local function readConfig()
  local file = io.open("dialer.cfg", "r")
  if file == nil then return end
  file:close()
  if not pcall(function() dofile("dialer.cfg") end) then
    io.stderr:write("Failed to load config file!\n")
  end
end

function IrisConfig(options)
  if type(options.IDC) == "number" and options.IDC >= 0 and options.IDC < 1e9 and math.floor(options.IDC) == options.IDC then
    IDC = options.IDC
  elseif options.IDC == nil then
    io.stderr:write("No IDC Provided\n")
  else
    io.stderr:write("IDC in config file is invalid\n")
  end

  if type(options.AutoCloseIris) == "boolean" then
    IrisSettings.AutoCloseIris = options.AutoCloseIris
  else
    io.stderr:write("AutoCloseIris in config file is invalid\n")
  end

  if type(options.NetworkPort) == "number" and options.NetworkPort > 0 and options.NetworkPort <= 65535 and math.floor(options.NetworkPort) == options.NetworkPort then
    ModemIDCPort = options.NetworkPort
    if HasModem then modem.open(ModemIDCPort) end
  elseif options.NetworkPort == nil then
    io.stderr:write("No IDC Network Port Provided\n")
  else
    io.stderr:write("IDC Network Port in config file is invalid\n")
  end

  IrisConfig = nil
end

function AdminAccess(options)
  if type(options.Quit) == "boolean" then AdminOnlySettings.Quit = options.Quit end
  if type(options.AddEntry) == "boolean" then AdminOnlySettings.AddEntry = options.AddEntry end
  if type(options.EditEntry) == "boolean" then AdminOnlySettings.EditEntry = options.EditEntry end
  if type(options.History) == "boolean" then AdminOnlySettings.History = options.History end
  if type(options.ToggleIris) == "boolean" then AdminOnlySettings.ToggleIris = options.ToggleIris end
  if type(options.AdminCanForceDialDHD) == "boolean" then AdminOnlySettings.AdminCanForceDialDHD = options.AdminCanForceDialDHD end
  AdminAccess = nil
end

function OtherSettings(options)
  if type(options.HideLocalAddr) == "boolean" then MiscSettings.HideLocalAddr = options.HideLocalAddr end
  if type(options.dialWithDHD) == "boolean" then MiscSettings.dialWithDHD = options.dialWithDHD end
  if type(options.LudicrousSpeed) == "boolean" then MiscSettings.LudicrousSpeed = options.LudicrousSpeed end
  OtherSettings = nil
end

function RedstoneSettings(options)
  if type(options.ExhaustVentSide) == "string" then RS_Settings.ExhaustVentSide = options.ExhaustVentSide end
  if type(options.ChevronEngagedSide) == "string" then RS_Settings.ChevronEngagedSide = options.ChevronEngagedSide end
  if type(options.WormholeOpenSide) == "string" then RS_Settings.WormholeOpenSide = options.WormholeOpenSide end
  if type(options.GateIsActiveSide) == "string" then RS_Settings.GateIsActiveSide = options.GateIsActiveSide end
  RedstoneSettings = nil
end

local function tableFormatter(tbl)
  local bufString = serialization.serialize(tbl)
  bufString = bufString:gsub("{","{\n  ")
  bufString = bufString:gsub(",}","}")
  bufString = bufString:gsub(",",",\n  ")
  bufString = bufString:gsub("}","\n}\n\n")
  return bufString
end

local function writeConfig()
  local file = io.open("dialer.cfg", "w")
  file:write("-- Do not edit this file directly unless you know what you are doing.\n\n")
  file:write("IrisConfig{\n  IDC="..tostring(IDC)..",\n  AutoCloseIris="..tostring(IrisSettings.AutoCloseIris)..",\n  NetworkPort="..tostring(ModemIDCPort).."\n}\n\n")
  file:write("AdminAccess"..tableFormatter(AdminOnlySettings))
  file:write("OtherSettings"..tableFormatter(MiscSettings))
  file:write("RedstoneSettings"..tableFormatter(RS_Settings))
  file:close()
end

readConfig()
writeConfig()
-- Config File IO End --------------------------------------------------------------

-- AdminList File IO ---------------------------------------------------------------
local function readAdminList()
  if filesystem.exists(shell.getWorkingDirectory().."/adminList.txt") then
    for line in io.lines("adminList.txt") do
      table.insert(AdminList, line)
    end
  else
    file = io.open("adminList.txt", "w")
    file:close()
  end
end

readAdminList()
-- AdminList File IO End -----------------------------------------------------------

-- Button Object -------------------------------------------------------------------
local Button = {}
Button.__index = Button
function Button.new(xPos, yPos, width, height, label, func, border)
  local self = setmetatable({}, Button)
  if xPos < 1 or xPos > term.window.width then xPos = 1 end
  if yPos < 1 or yPos > term.window.height then yPos = 1 end
  if (width-2) < unicode.len(label) then width = unicode.len(label)+2 end
  if height < 3 then height = 3 end
  if border == nil then
    self.border = true
  else
    self.border = border
  end
  self.xPos = xPos
  self.yPos = yPos
  self.width = width
  self.height = height
  self.label = label
  self.func = func
  self.visible = false
  self.disabled = false
  return self
end

function Button.display(self, x, y)
  table.insert(ActiveButtons, 1, self)
  if (self.width-2) < unicode.len(self.label) then self.width = unicode.len(self.label)+2 end
  if x ~= nil and y ~= nil then
    self.xPos = x
    self.yPos = y
  end
  if self.border then
    gpu.fill(self.xPos+1, self.yPos, self.width-2, 1, "─")
    gpu.fill(self.xPos+1, self.yPos+self.height-1, self.width-2, 1, "─")
    gpu.fill(self.xPos, self.yPos+1, 1, self.height-2, "│")
    gpu.fill(self.xPos+self.width-1, self.yPos+1, 1, self.height-2, "│")
    gpu.set(self.xPos, self.yPos, "┌")
    gpu.set(self.xPos+self.width-1, self.yPos, "┐")
    gpu.set(self.xPos, self.yPos+self.height-1, "└")
    gpu.set(self.xPos+self.width-1, self.yPos+self.height-1, "┘")
  end
  gpu.set(self.xPos+1, self.yPos+1, self.label)
  self.visible = true
end

function Button.hide(self)
  self.visible = false
  for i,v in ipairs(ActiveButtons) do
    if v == self then table.remove(ActiveButtons, i) end
  end
  if self.border then
    gpu.fill(self.xPos, self.yPos, self.width, self.height, " ")
  else
    gpu.fill(self.xPos+1, self.yPos+1, self.width-2, 1, " ")
  end
end

function Button.disable(self, bool)
  if bool == nil then
    self.disabled = false
  else
    self.disabled = bool
  end
  if self.disabled then gpu.setForeground(0x0F0F0F) end
  if self.visible then self:display() end
  gpu.setForeground(0xFFFFFF)
end

function Button.touch(self, x, y)
  local wasTouched = false
  if self.visible and not self.disabled then
    if self.border then
      if x >= self.xPos and x <= (self.xPos+self.width-1) and y >= self.yPos and y <= (self.yPos+self.height-1) then wasTouched = true end
    else
      if x >= self.xPos+1 and x <= (self.xPos+self.width-2) and y >= self.yPos+1 and y <= (self.yPos+self.height-2) then wasTouched = true end
    end
  end
  if wasTouched then
    gpu.setBackground(0x878787)
    gpu.set(self.xPos+1, self.yPos+1, self.label)
    gpu.setBackground(0x000000)
    if self.visible then gpu.set(self.xPos+1, self.yPos+1, self.label) end
    self.func()
  end
  return wasTouched
end

function Button.forceTouch(self)
  self:touch(self.xPos+1, self.yPos+1)
end
-- End of Button Object ------------------------------------------------------------

-- Check Box Object ----------------------------------------------------------------
local CheckBox = {}
CheckBox.__index = CheckBox
function CheckBox.new(xPos, yPos, tbl, tblKey, func)
  local self = setmetatable({}, CheckBox)
  self.xPos = xPos
  self.yPos = yPos
  self.tbl = tbl
  self.tblKey = tblKey
  self.visible = false
  self.disabled = false
  self.isChecked = self.tbl[self.tblKey]
  self.func = func
  return self
end

function CheckBox.display(self, isChecked, x, y)
  table.insert(ActiveButtons, 1, self)
  if isChecked ~= nil then
    self.isChecked = isChecked
  end
  if x ~= nil and y ~= nil then
    self.xPos = x
    self.yPos = y
  end
  gpu.set(self.xPos, self.yPos, "[ ]")
  if self.isChecked then
    gpu.setForeground(0x00FF00)
    gpu.set(self.xPos+1, self.yPos, "X")
    gpu.setForeground(0xFFFFFF)
  end
  self.visible = true
end

function CheckBox.hide(self)
  self.visible = false
  for i,v in ipairs(ActiveButtons) do
    if v == self then table.remove(ActiveButtons, i) end
  end
  gpu.fill(self.xPos, self.yPos, 3, 1, " ")
end

function CheckBox.disable(self, bool)
  if bool == nil then
    self.disabled = false
  else
    self.disabled = bool
  end
  if self.disabled then gpu.setForeground(0x0F0F0F) end
  if self.visible then self:display() end
  gpu.setForeground(0xFFFFFF)
end

function CheckBox.touch(self, x, y)
  local wasTouched = false
  if self.visible and not self.disabled and x >= self.xPos and x < (self.xPos+3) and y == self.yPos then
    wasTouched = true
  end
  if wasTouched then
    if self.isChecked then
      self.isChecked = false
    elseif not self.isChecked then
      self.isChecked = true
    end
    self.tbl[self.tblKey] = self.isChecked
    self.func()
    self:display()
  end
  return wasTouched
end
-- End Check Box Object ------------------------------------------------------------

-- Special Functions ---------------------------------------------------------------
local function alert(msg, lvl)
  if lvl == nil or lvl < 0 then lvl = 3 end
  if type(msg) ~= "string" then error("alert() requires a string") end
  if ChildThread.AlertThread ~= nil then ChildThread.AlertThread:kill() end
  if lvl >= 0 then
    ChildThread.AlertThread = thread.create(function()
        gpu.setForeground(0x000000)
        if lvl == 0 or lvl == 1 then
          gpu.setBackground(0x00FF00)
          if lvl == 1 then computer.beep(1000) end
        elseif lvl == 2 then
          computer.beep()
          gpu.setBackground(0xFFFF00)
        elseif lvl == 3 then
          computer.beep(450, 0.5)
          gpu.setForeground(0xFFFFFF)
          gpu.setBackground(0xFF0000)
        end
        gpu.fill(1, 1, term.window.width, 1, " ")
        gpu.fill(1, term.window.height, term.window.width, 1, " ")
        gpu.set ((term.window.width/2)-(unicode.len(msg)/2), 1, msg)
        gpu.setForeground(0xFFFFFF)
        gpu.setBackground(0x000000)
        os.sleep(10)
        gpu.setForeground(0xFFFFFF)
        gpu.setBackground(0x000000)
        gpu.fill(1, 1, term.window.width, 1, " ")
        gpu.fill(1, term.window.height, term.window.width, 1, " ")
    end)
  else
    gpu.fill(1, 1, term.window.width, 1, " ")
    gpu.fill(1, term.window.height, term.window.width, 1, " ")
  end
end

local function checkGlyph(glyph, adrType)
  local isGood = false
  local fixedGlyph = "Unknown"
  local glyphsTbl = {}
  if adrType == "UN" then
    for i=1,36,1 do
      if string.lower(glyph) == "g"..i or string.lower(glyph) == "glyph "..i or string.lower(glyph) == "glyph"..i then
        fixedGlyph = "Glyph "..i
        isGood = true
        break
      end
    end
  else
    if adrType == "MW" then
      glyphsTbl = GlyphsMW
      if glyph == "PointofOrigin" or glyph == "Point of Origin" or glyph == "Origin" then
        fixedGlyph = "Point of Origin"
        isGood = true
        return isGood, fixedGlyph
      end
    elseif adrType == "PG" then
      glyphsTbl = GlyphsPG
      if glyph == "Subido" then
        fixedGlyph = "Subido"
        isGood = true
        return isGood, fixedGlyph
      end
    end
    for i,v in ipairs(glyphsTbl) do
      if string.lower(string.gsub(glyph,"%s+","")) == string.lower(string.gsub(v,"%s+","")) then
        fixedGlyph = v
        isGood = true
        break
      end
    end
  end
  return isGood, fixedGlyph
end

function GateEntry(ge)
  if ge.gateAddress.UN ~= nil and #ge.gateAddress.UN ~= 0 then
    for i,v in ipairs(ge.gateAddress.UN) do
      _,ge.gateAddress.UN[i] = checkGlyph(v, "UN")
    end
  end
  if ge.fave == nil then ge.fave = false end
  table.insert(gateEntries, ge)
end

function HistoryEntry(ge)
  if ge.gateAddress.UN ~= nil and #ge.gateAddress.UN ~= 0 then
    for i,v in ipairs(ge.gateAddress.UN) do
      _,ge.gateAddress.UN[i] = checkGlyph(v, "UN")
    end
  end
  table.insert(historyEntries, ge)
end

local function initialLoadAddressFile()
  local file = io.open(DatabaseFile, "r")
  if file == nil then
    file = io.open(DatabaseFile, "w")
  end
  file:close()
  gateEntries = {}
  historyEntries = {}
  dofile(DatabaseFile)
  if #gateEntries > 0 then
      file, msg = io.open(DatabaseFileBackup, "w")
      for i,v in ipairs(gateEntries) do
        file:write("GateEntry"..serialization.serialize(v).."\n")
      end
      file:write("\n")
      for i,v in ipairs(historyEntries) do
        file:write("HistoryEntry"..serialization.serialize(v).."\n")
      end
      file:close()
  else
    file = io.open(DatabaseFileBackup, "r")
    if file ~= nil then
      file:close()
      dofile(DatabaseFileBackup)
    end
  end
end

local function readAddressFile()
  local file = io.open(DatabaseFile, "r")
  if file == nil then
    file = io.open(DatabaseFile, "w")
  end
  file:close()
  gateEntries = {}
  historyEntries = {}
  dofile(DatabaseFile)
end

local function writeToDatabase()
  local status, value = pcall(function() return ChildThread.databaseWrite:status() end)
  if status == true then
    while ChildThread.databaseWrite:status() ~= "dead" do end
  end
  ChildThread.databaseWrite = thread.create(function()
    local file, msg = io.open(DatabaseFile, "w")
    for i,v in ipairs(gateEntries) do
      file:write("GateEntry"..serialization.serialize(v).."\n")
    end
    file:write("\n")
    for i,v in ipairs(historyEntries) do
      file:write("HistoryEntry"..serialization.serialize(v).."\n")
    end
    file:close()
    readAddressFile()
  end)

  -- if DatabaseWriteTimer ~= nil then
    -- event.cancel(DatabaseWriteTimer)
    -- DatabaseWriteTimer = nil
  -- end
  -- DatabaseWriteTimer = event.timer(5, function()
    -- -- alert("Database Saved", 1) -- For Debug
    -- local file, msg = io.open(DatabaseFile, "w")
    -- for i,v in ipairs(gateEntries) do
      -- file:write("GateEntry"..serialization.serialize(v).."\n")
    -- end
    -- file:write("\n")
    -- for i,v in ipairs(historyEntries) do
      -- file:write("HistoryEntry"..serialization.serialize(v).."\n")
    -- end
    -- file:close()
    -- readAddressFile()
    -- DatabaseWriteTimer = nil
  -- end)
  GateEntriesWindow.update()
end

local function runPlugin()
  if io.open("plugin.lua", "r") == nil then
    return
  end

  ChildThread.pluginThread = thread.create(function()
    local status, err = xpcall(function()
      dofile("plugin.lua")
    end, debug.traceback)
    if err ~= nil then
      ErrorMessage = "Error in Plugin \n"..err
    end
    HadNoError = status
  end)
end

local function addressToString(tbl)
  local str = "["
  for i,v in ipairs(tbl) do
    str = str..v
    if #tbl ~= i then str = str.." - " end
  end
  str = str.."]"
  return str
end

local function clearDisplay()
  for k in pairs(buttons) do buttons[k]:hide() end
  gateRingDisplay.isActive = false
  gpu.fill(41, 2, 120-(2*glyphListWindow.width), 39, " ")
  gpu.fill(43, 2, 118-(2*glyphListWindow.width), 42, " ")
end

function entriesDuplicateCheck(adr, entriesTable, adrType, pos)
  local hasDuplicate = false
  local duplicateNames = {}
  local entriesBuffer = {}
  local glyph = ""
  if #entriesTable ~= 0 then
    if pos > 6 then
      hasDuplicate = true
      for i,v in ipairs(entriesTable) do table.insert(duplicateNames, v.name) end
    else
      for i,v in ipairs(entriesTable) do
        if v.gateAddress[adrType] ~= nil and #v.gateAddress[adrType] ~= 0 then
          _,glyph = checkGlyph(adr[pos], adrType)
          if glyph == v.gateAddress[adrType][pos] then
            table.insert(entriesBuffer, v)
          end
        end
      end
      pos = pos + 1
      hasDuplicate, duplicateNames = entriesDuplicateCheck(adr, entriesBuffer, adrType, pos)
    end
  end
  return hasDuplicate, duplicateNames
end

function parseAddressString(adrStr, adrType)
  local adrBuf = {}
  if type(adrStr) == "string" then
    for w in string.gmatch(string.gsub(adrStr, "%s", ""), "%w+") do
      table.insert(adrBuf, w)
    end
    if #adrBuf > 0 then
      for i,v in ipairs(adrBuf) do
        _,adrBuf[i] = checkGlyph(v, adrType)
      end
    end
  end
  return adrBuf
end

local function userInput(x, y, maxLength, touchExits, timeoutEnabled)
  local threadStates = {}
  for _,v in pairs(ChildThread) do
    threadStates[v] = v:status()
    v:suspend()
  end
  local success = true
  local inputString = ""
  local strLength = 0
  if maxLength == nil or maxLength == 0 then maxLength = 32 end
  term.setCursor(x, y)
  term.setCursorBlink(true)
  gpu.setBackground(0x878787)
  gpu.fill(x, y, maxLength, 1, " ")
  gpu.setBackground(0x000000)
  local timeoutTimer = 0
  if timeoutEnabled then
    timeoutTimer = event.timer(10, function()
      alert("User Input Timed Out", 1)
      computer.pushSignal("touch", nil, 0, 0, 0, "FakePlayer")
    end)
  end
  while true do
    -- term.setCursorBlink(true)
    local e, address, arg1, arg2, arg3 = term.pull()
    if e == "touch" and touchExits then
      success = false
      break
    end
    if e == "key_down" then
      if arg2 ~= 28 and arg2 ~= 14 and arg1 ~= 0 and strLength < maxLength then -- Not Enter, Backspace, or Other
        inputString = inputString..unicode.char(arg1)
      elseif arg2 == 14 then -- Backspace Key
        inputString = unicode.wtrunc(inputString, strLength)
      elseif arg2 == 28 then -- Enter Key
        break
      end
      strLength = unicode.len(inputString)
      gpu.setBackground(0x878787)
      gpu.fill(x, y, maxLength, 1, " ")
      gpu.set(x, y, inputString)
      gpu.setBackground(0x000000)
      term.setCursor(x+strLength, y)
    end
    -- if WasCanceled then
      -- WasCanceled = false
      -- inputString = ""
      -- break
    -- end
  end
  event.cancel(timeoutTimer)
  -- gpu.setBackground(0x000000)
  -- term.setCursorBlink(false)
  -- gpu.fill(x, y, maxLength, 1, " ")
  for k,v in pairs(threadStates) do
    if v == "running" then k:resume() end
  end
  -- alert("Input Closed", 1) -- For Debug
  return inputString, success
end

function updateHistory()
  if #DialedAddress < 6 then return end
  local adrName = "UNKNOWN"
  local address = {}
  local timeString = os.date("%H:%M %d/%m", getRealTime())..""
  for i,v in ipairs(DialedAddress) do
    if i < #DialedAddress then
      table.insert(address, v)
    end
  end
  local inDatabase, duplicateNames = entriesDuplicateCheck(address, gateEntries, GateType, 1)
  if inDatabase then
    adrName = duplicateNames[1]
  end
  table.insert(historyEntries, 1, {name=adrName, gateAddress={[GateType]=address}, t=getRealTime(), AdminOnly=AdminDialed})
  while #historyEntries > 50 do
    table.remove(historyEntries)
  end
  GateEntriesWindow.range.botH = 1
  GateEntriesWindow.range.topH = GateEntriesWindow.range.height
  writeToDatabase()
  AdminDialed = false
end

function getRealTime()
  local tmpFile = io.open("/tmp/.time", "w")
  tmpFile:write()
  tmpFile:close()
  return math.floor(filesystem.lastModified("/tmp/.time") / 1000)
end

local function isAuthorized(name, isEnabled)
  local authorized = false
  if type(isEnabled) ~= "boolean" then isEnabled = true end
  if isEnabled then
    if #AdminList == 0 then
      authorized = true
    else
      for _,v in ipairs(AdminList) do
        if string.lower(v) == string.lower(name) then
          authorized = true
          break
        end
      end
    end
  else
    authorized = true
  end
  if not authorized then alert("ACCESS DENIED", 2) end
  return authorized
end
-- End of Special Functions --------------------------------------------------------

-- Info Center ---------------------------------------------------------------------
local function displaySystemStatus()
  local xPos = 2
  local yPos = 45
  local energyStored = 0
  local energyMax = 0
  local capCount = 0
  local irisState = nil
  local status, err = pcall(function()
    energyStored = sg.getEnergyStored()
    energyMax = sg.getMaxEnergyStored()
    capCount = sg.getCapacitorsInstalled()
  end)
  if status == false then
    ErrorMessage = "Stargate Has Been Disconnected"
    HadNoError = false
  end
  pcall(function()
    irisState = sg.getIrisState()
  end)
  -- local freeMemory = computer.freeMemory()
  -- local totalComputerMemory = computer.totalMemory()
  gpu.set(17, term.window.height-6, "╡")
  gpu.set(29, term.window.height-6, "╞")
  gpu.setForeground(0x000000)
  if GateStatusString == "open" then
    gpu.setBackground(0xFFFF00)
    gpu.set(18, term.window.height-6, " GATE OPEN ")
  else
    gpu.setBackground(0x00FF00)
    gpu.set(18, term.window.height-6, "GATE CLOSED")
  end
  gpu.setForeground(0xFFFFFF)
  gpu.setBackground(0x000000)
  gpu.set(30, term.window.height-6, "═════════════")
  if IrisType ~= nil and IrisType ~= "NULL" then
    if IrisType == "SHIELD" then
      gpu.set(30, term.window.height-6, "╡░░░░░░░░░░╞")
      if irisState == "OPENED" then
        if GateStatusString == "open" and GateStatusBool == false then
          gpu.setForeground(0x000000)
          gpu.setBackground(0xFFFF00)
        end
        gpu.set(31, term.window.height-6, "SHIELD OFF")
      elseif irisState == "CLOSED" then
        gpu.set(31, term.window.height-6, "SHIELD ON ")
      end
    else
      gpu.set(30, term.window.height-6, "╡░░░░░░░░░░░╞")
      if irisState == "OPENED" then
        if GateStatusString == "open" and GateStatusBool == false then
          gpu.setForeground(0x000000)
          gpu.setBackground(0xFFFF00)
        end
        gpu.set(31, term.window.height-6, " IRIS OPEN ")
      elseif irisState == "CLOSED" then
        gpu.set(31, term.window.height-6, "IRIS CLOSED")
      end
    end
    gpu.setForeground(0xFFFFFF)
    gpu.setBackground(0x000000)
  end
  gpu.fill(xPos, yPos, 44, 4, " ")
  gpu.set(xPos+1, yPos, "Energy Level: "..energyStored.."/"..energyMax.." RF "..math.floor((energyStored/energyMax)*100).."%")
  gpu.set(xPos+1, yPos+1, "Capacitors Installed: "..capCount.."/3")
  -- gpu.set(xPos+1, yPos+3, "Computer Memory Remaining: "..math.floor((freeMemory/totalComputerMemory)*100).."%")
  gpu.set(xPos+1, yPos+3, "Computer Memory Remaining: "..freeMemoryPercent)
  if IrisType ~= nil and IrisType ~= "NULL" then
    gpu.set(xPos+1, yPos+2, "Iris Durability: "..IrisDurability)
  end
end

local infoExtensionSwitch = function() end

local function displayLocalAddress()
  gpu.set(48, 45, "Milky Way ")
  gpu.set(48, 46, "Universe  ")
  gpu.set(48, 47, "Pegasus   ")
  if MiscSettings.HideLocalAddr then
    gpu.setForeground(0xFF0000)
    gpu.set(58, 45, "REDACTED")
    gpu.set(58, 46, "REDACTED")
    gpu.set(58, 47, "REDACTED")
    gpu.setForeground(0xFFFFFF)
  else
    gpu.set(58, 45, addressToString(localMWAddress))
    gpu.set(58, 46, addressToString(localUNAddress))
    gpu.set(58, 47, addressToString(localPGAddress))
  end
end

local ConfigPage = {}
ConfigPage.timer = 0
ConfigPage.autoIrisCheckBox = CheckBox.new(64, 46, IrisSettings, "AutoCloseIris", writeConfig)

ConfigPage.changeIDCButton = Button.new(65, 46, 0, 0, "         ", function()
  ConfigPage.changeIDCButton:hide()
  -- if not event.cancel(ConfigPage.timer) then alert("FAILED",2) end -- For debug
  local newIDC, successful = userInput(66, 47, 9, true, true)
  if successful then
    if newIDC == "" then
      alert("IDC Was Cleared", 2)
      IDC = nil
      writeConfig()
    else
      newIDC = tonumber(newIDC)
      if type(newIDC) == "number" and newIDC >= 0 and newIDC < 1e9 and math.floor(newIDC) == newIDC then
        alert("IDC Has Been Changed", 1)
        IDC = newIDC
        writeConfig()
      else
        alert("Invalid IDC", 2)
      end
    end
  end
  if infoExtensionMode == "CONFIG" then ConfigPage.show() end
end, false)

ConfigPage.changePortButton = Button.new(65, 47, 0, 0, "     ", function()
  ConfigPage.changePortButton:hide()
  if not event.cancel(ConfigPage.timer) then alert("FAILED",2) end
  local newPort, successful = userInput(66, 48, 5, true, true)
  if successful then
    if newPort == "" then
      alert("IDC Network Port Was Closed", 2)
      if ModemIDCPort ~= nil then modem.close(ModemIDCPort) end
      ModemIDCPort = nil
      writeConfig()
    else
      newPort = tonumber(newPort)
      if type(newPort) == "number" and newPort > 0 and newPort <= 65535 and math.floor(newPort) == newPort then
        alert("IDC Network Port Has Been Changed", 1)
        if ModemIDCPort ~= nil then modem.close(ModemIDCPort) end
        ModemIDCPort = newPort
        modem.open(ModemIDCPort)
        writeConfig()
      else
        alert("Invalid Port Number", 2)
      end
    end
  end
  if infoExtensionMode == "CONFIG" then ConfigPage.show() end
end, false)

ConfigPage.adminOffset = 75
ConfigPage.adminQuitCheckBox = CheckBox.new(ConfigPage.adminOffset+15, 46, AdminOnlySettings, "Quit", writeConfig)
ConfigPage.adminAddEntryCheckBox = CheckBox.new(ConfigPage.adminOffset+21, 47, AdminOnlySettings, "AddEntry", writeConfig)
ConfigPage.adminEditEntryCheckBox = CheckBox.new(ConfigPage.adminOffset+18, 48, AdminOnlySettings, "EditEntry", writeConfig)
ConfigPage.adminHistoryCheckBox = CheckBox.new(ConfigPage.adminOffset+43, 46, AdminOnlySettings, "History", writeConfig)
ConfigPage.adminToggleIrisCheckBox = CheckBox.new(ConfigPage.adminOffset+39, 47, AdminOnlySettings, "ToggleIris", writeConfig)

ConfigPage.otherOffset = 121
ConfigPage.hideLocalAddrCheckBox = CheckBox.new(ConfigPage.otherOffset+23, 46, MiscSettings, "HideLocalAddr", writeConfig)
ConfigPage.dialWithDHDCheckBox = CheckBox.new(ConfigPage.otherOffset+18, 47, MiscSettings, "dialWithDHD", writeConfig)

function ConfigPage.show()
  ConfigPage.timer = event.timer(10, function() infoExtensionSwitch("ADDRESS") end)
  ConfigPage.autoIrisCheckBox:display()
  gpu.set(47, 45, "╭Iris / Shield Settings─────")
  gpu.fill(47, 46, 1, 3, "│")
  gpu.set(48, 46, "Auto Close Iris [ ]")
  ConfigPage.changeIDCButton:display()
  if IrisSettings.AutoCloseIris == true then
    gpu.setForeground(0x00FF00)
    gpu.set(65, 46, "X")
    gpu.setForeground(0xFFFFFF)
  end
  gpu.set(48, 47, "Iris/Shield Code:")
  gpu.setBackground(0x878787)
  gpu.set(66, 47, "         ")
  if IDC ~= nil then gpu.set(66, 47, tostring(IDC)) end
  gpu.setBackground(0x000000)
  gpu.set(48,48, "IDC Network Port:")
  if HasModem then
    ConfigPage.changePortButton:display()
    gpu.setBackground(0x878787)
    gpu.set(66, 48, "     ")
    if ModemIDCPort ~= nil then gpu.set(66, 48, tostring(ModemIDCPort)) end
    gpu.setBackground(0x000000)
  else
    gpu.set(66, 48, "No Card")
  end
  gpu.fill(ConfigPage.adminOffset, 46, 1, 3, "│")
  gpu.set(ConfigPage.adminOffset, 45, "┬Admin Only Access Settings──────────────────────────╮")
  if #AdminList > 0 then
    gpu.set(ConfigPage.adminOffset+1, 46, "Quit Program: [ ]")
    ConfigPage.adminQuitCheckBox:display()
    gpu.set(ConfigPage.adminOffset+1, 47, "Add New Gate Entry: [ ]")
    ConfigPage.adminAddEntryCheckBox:display()
    gpu.set(ConfigPage.adminOffset+1, 48, "Edit Gate Entry: [ ]")
    ConfigPage.adminEditEntryCheckBox:display()
    gpu.set(ConfigPage.adminOffset+26, 46, "Dialing History: [ ]")
    ConfigPage.adminHistoryCheckBox:display()
    gpu.set(ConfigPage.adminOffset+26, 47, "Toggle Iris: [ ]")
    ConfigPage.adminToggleIrisCheckBox:display()
  else
    gpu.setForeground(0xFFFF00)
    gpu.set(ConfigPage.adminOffset+5, 47, "There are no Names in the Admin List")
    gpu.setForeground(0xFFFFFF)
  end
  gpu.fill(ConfigPage.otherOffset, 46, 1, 3, "│")
  gpu.set(ConfigPage.otherOffset, 45, "┬Other Settings───────────────────────╮")
  gpu.set(ConfigPage.otherOffset+1, 46, "Hide Local Addresses: [ ]")
  ConfigPage.hideLocalAddrCheckBox:display()
  if component.isAvailable("dhd") then
    gpu.set(ConfigPage.otherOffset+1, 47, "Use DHD to Dial: [ ]")
    ConfigPage.dialWithDHDCheckBox:display()
  end
  gpu.fill(ConfigPage.otherOffset+38, 46, 1, 3, "│")
end

function ConfigPage.hide()
  event.cancel(ConfigPage.timer)
  ConfigPage.autoIrisCheckBox:hide()
  ConfigPage.changeIDCButton:hide()
  ConfigPage.changePortButton:hide()

  ConfigPage.adminQuitCheckBox:hide()
  ConfigPage.adminAddEntryCheckBox:hide()
  ConfigPage.adminEditEntryCheckBox:hide()
  ConfigPage.adminHistoryCheckBox:hide()
  ConfigPage.adminToggleIrisCheckBox:hide()

  ConfigPage.hideLocalAddrCheckBox:hide()
  ConfigPage.dialWithDHDCheckBox:hide()
end

function infoExtensionSwitch(mode)
  if DebugMode then
    gpu.set(47, 44, "╡This Stargate's Addresses╞═╡Settings╞═╡Debug╞")
  else
    gpu.set(47, 44, "╡This Stargate's Addresses╞═╡Settings╞════════")
  end
  gpu.fill(47, 45, 113, 4, " ")
  ChildThread.debugWindowThread:suspend()
  if infoExtensionMode == "CONFIG" then ConfigPage.hide() end
  if mode == "ADDRESS" then
    gpu.setBackground(0x878787)
    gpu.set(48, 44, "This Stargate's Addresses")
    gpu.setBackground(0x000000)
    displayLocalAddress()
    infoExtensionMode = "ADDRESS"
  elseif mode == "CONFIG" then
    gpu.setBackground(0x878787)
    gpu.set(76, 44, "Settings")
    gpu.setBackground(0x000000)
    infoExtensionMode = "CONFIG"
    ConfigPage.show()
  elseif mode == "DEBUG" then
    gpu.setBackground(0x878787)
    gpu.set(87, 44, "Debug")
    gpu.setBackground(0x000000)
    infoExtensionMode = "DEBUG"
    ChildThread.debugWindowThread:resume()
  end
end

local addressButton = Button.new(47, 43, 0, 0, "This Stargate's Addresses", function() infoExtensionSwitch("ADDRESS") end, false)
local configButton = Button.new(75, 43, 0, 0, "Settings", function()
  if isAuthorized(User) then
    infoExtensionSwitch("CONFIG")
  end
end, false)
local debugButton = Button.new(86, 43, 0, 0, "Debug", function() infoExtensionSwitch("DEBUG") end, false)

local function toggleDebugMode()
    if not DebugMode then
      alert("DEBUG MODE ACTIVATED", 1)
      DebugMode = true
      debugButton:display()
      infoExtensionSwitch("DEBUG")
      ChildThread.debugWindowThread:resume()
    elseif DebugMode then
      debugButton:hide()
      gpu.set(86, 44, "═══════")
      alert("DEBUG MODE DEACTIVATED", 1)
      DebugMode = false
      ChildThread.debugWindowThread:suspend()
      if infoExtensionMode == "DEBUG" then infoExtensionSwitch("ADDRESS") end
      gpu.fill(150, 43, 10, 1, " ")
    end
end

local function displayInfoCenter()
  gpu.setBackground(0x000000)
  gpu.fill(1, term.window.height-6, term.window.width, 1, "═")
  gpu.fill(1, term.window.height-5, 1, 4, "║")
  gpu.fill(46, term.window.height-5, 1, 4, "║")
  gpu.fill(term.window.width, term.window.height-5, 1, 4, "║")
  gpu.fill(1, term.window.height-1, term.window.width, 1, "═")
  gpu.set(1, term.window.height-6, "╔╡System Status╞")
  gpu.set(46, term.window.height-6, "╦")
  gpu.set(47, term.window.height-6, "╡This Stargate's Addresses╞")
  gpu.set(term.window.width, term.window.height-6, "╗")
  gpu.set(1, term.window.height-1, "╚")
  gpu.set(46, term.window.height-1, "╩")
  gpu.set(term.window.width, term.window.height-1, "╝")
  addressButton:display()
  configButton:display()
  infoExtensionSwitch("ADDRESS")
end

ChildThread.statusThread = thread.create(function()
  local status, err = xpcall(function()
    while HadNoError do
      displaySystemStatus()
      os.sleep(0.05)
    end
  end, debug.traceback)
  if err ~= nil then ErrorMessage = err end
  HadNoError = status
end)

ChildThread.debugWindowThread = thread.create(function() -- For Debug
  local status, err = xpcall(function()
    while HadNoError do
      local used = RootDrive.spaceUsed()
      local total = RootDrive.spaceTotal()
      local dialedAddress = nil
      pcall(function() dialedAddress = sg.dialedAddress end)
      if DebugMode then
        gpu.fill(48, 45, 110, 4, " ")
        -- gpu.set(48, 45, "DHD_AdrEntryMode: "..tostring(DHD_AdrEntryMode))
        gpu.set(48, 45, "ComputerDialingWithDHD: "..tostring(ComputerDialingWithDHD))
        gpu.set(48, 46, "DialingInterlocked: "..tostring(DialingInterlocked))
        gpu.set(48, 47, "ComputerDialingInterlocked: "..tostring(ComputerDialingInterlocked))
        -- gpu.set(48, 47, "adrEntryType: "..tostring(adrEntryType))
        gpu.set(84, 46, "dialerAdrEntryMode: "..tostring(dialerAdrEntryMode))
        gpu.set(84, 45, "glyphListWindow.locked: "..tostring(glyphListWindow.locked))
        gpu.set(48, 48, tostring(dialedAddress))
        gpu.set(84, 47, "Gate Status: "..tostring(GateStatusString).." | "..tostring(GateStatusBool))
        -- gpu.set(84, 47, "WasCanceled: "..tostring(WasCanceled))
        -- gpu.set(120, 45, "Drive Usage: "..used.."/"..total.." "..math.floor((used/total)*100).."%")
        -- gpu.set(120, 45, "Index: "..tostring(GateEntriesWindow.selectedIndex))
        -- gpu.set(120, 45, "UNGateResetting: "..tostring(UNGateResetting))
        gpu.set(120, 45, "manualAdrEntryMode: "..tostring(manualAdrEntryMode))
        gpu.set(120, 46, "editGateEntryMode: "..tostring(editGateEntryMode))
        gpu.set(120, 47, "OutgoingWormhole: "..tostring(OutgoingWormhole))
        -- gpu.set(120, 47, "addAddressMode: "..tostring(addAddressMode))
        -- gpu.set(120, 47, "DatabaseWriteTimer ID: "..tostring(DatabaseWriteTimer))
        -- gpu.set(120, 46, "IrisState: "..tostring(sg.getIrisState()))
        -- gpu.set(120, 47, "IrisType: "..tostring(IrisType))
        -- gpu.set(120, 46, "AdminOnlyQuit: "..tostring(AdminOnlySettings["Quit"]))
        -- gpu.set(120, 47, "MainLoop: "..tostring(MainLoop))
      end
      os.sleep(0.1)
    end
  end, debug.traceback)
  if err ~= nil then ErrorMessage = err end
  HadNoError = status
end)
-- End of Info Center --------------------------------------------------------------


-- Gate Entries Window -------------------------------------------------------------
GateEntriesWindow = {}
function GateEntriesWindow.set()
  local self = GateEntriesWindow
  self.xPos = 2
  self.yPos = 3
  self.width = 37
  self.height = 37
  gpu.fill(1, 2, 40, 39, " ")
  self.entries = {}
  self.range = {}
  self.range.bot = 1
  self.range.height = 37
  self.range.top = self.range.height
  self.range.botH = 1
  self.range.topH = self.range.height
  self.scrollingTimer = nil
  self.locked = false
  if GateType == "MW" then self.localAddress = localMWAddress
  elseif GateType == "UN" then self.localAddress = localUNAddress
  elseif GateType == "PG" then self.localAddress = localPGAddress
  end
  self.mode = "database"
  gpu.set(1, 2,  "╔╡Gate Entries╞══════════════╡History╞╗")
  gpu.set(1, 40, "╚═════════════════════════════════════╝")
  gpu.fill(1, 3, 1, 37, "║")
  gpu.fill(39, 3, 1, 37, "║")
  self.scrollUpButton = Button.new(3, 39, 0, 0, "↑PgUp↑", function()
    GateEntriesWindow.increment(-1)
  end, false)
  self.scrollDnButton = Button.new(30, 39, 0, 0, "↓PgDn↓", function()
    GateEntriesWindow.increment(1)
  end, false)
  self.clearHistoryButton = Button.new(13, 39, 0, 0, "Clear History", function()
    historyEntries = {}
    writeToDatabase()
    -- GateEntriesWindow.clearHistoryButton:hide()
  end, false)
  self.update()
end

function GateEntriesWindow.increment(inc)
  local self = GateEntriesWindow
  if self.scrollingTimer == nil then
    self.scrollingTimer = event.timer(0.05, function() self.scrollingTimer = nil end)
    if self.mode == "database" then
      if (self.range.top + inc) > #gateEntries or (self.range.bot + inc) < 1 then
        return
      else
        self.range.bot = self.range.bot + inc
        self.range.top = self.range.top + inc
        self.display()
      end
    elseif self.mode == "history" then
      if (self.range.topH + inc) > #historyEntries or (self.range.botH + inc) < 1 then
        return
      else
        self.range.botH = self.range.botH + inc
        self.range.topH = self.range.topH + inc
        self.display()
      end
    end
  end
end

function GateEntriesWindow.update()
  local self = GateEntriesWindow
  local strBuf = ""
  local dialable = true
  self.entryStrings = {}
  self.canDial = {}
  gpu.setBackground(0x878787)
  if self.mode == "database" then
    gpu.set(3, 2,  "Gate Entries")
    gpu.setBackground(0x000000)
    gpu.set(31, 2,  "History")
    self.loadedEntries = gateEntries
    self.clearHistoryButton:hide()
    gpu.set(13, 40, "═══════════════")
  elseif self.mode == "history" then
    gpu.set(31, 2,  "History")
    gpu.setBackground(0x000000)
    gpu.set(3, 2,  "Gate Entries")
    self.loadedEntries = historyEntries
    if #historyEntries > 0 then
      self.clearHistoryButton:display()
      gpu.set(13, 40, "╡░░░░░░░░░░░░░╞")
      self.clearHistoryButton:display()
    else
      self.clearHistoryButton:hide()
      gpu.set(13, 40, "═══════════════")
    end
  end
  for i,v in ipairs(self.loadedEntries) do
    strBuf = v.name
    if self.mode == "database" then
      if entriesDuplicateCheck(self.localAddress, {v}, GateType, 1) then
        -- strBuf = strBuf.." [This Stargate]"
        strBuf = "[This Stargate] "..strBuf
        dialable = false
      elseif v.gateAddress[GateType] ~= nil and #v.gateAddress[GateType] ~= 0 then
        -- strBuf = strBuf.." ("..(#v.gateAddress[GateType]+1).." Glyphs)"
        dialable = true
      else
        strBuf = strBuf.." [Empty "..GateType.." Address]"
        dialable = false
      end
    end
    if self.mode == "database" then
      while unicode.len(strBuf) < self.width-8 do
        strBuf = strBuf.." "
      end
    end
    if unicode.len(strBuf) > self.width-6 then strBuf = unicode.wtrunc(strBuf, self.width-7) end -- Truncate String to not go past border
    if self.mode == "history" and v.t ~= nil then
      if v.gateAddress[GateType] ~= nil and #v.gateAddress[GateType] > 0 then
        dialable = true
      else
        dialable = false
      end
      while unicode.len(strBuf) < 23 do
        strBuf = strBuf.." "
      end
      strBuf = strBuf.." "..os.date("%d/%m %H:%M", v.t)
    end
    table.insert(self.entryStrings, strBuf)
    table.insert(self.canDial, dialable)
  end
  if #self.entryStrings > self.range.height then
    gpu.set(3, 40, "╡░░░░░░╞")
    gpu.set(30, 40, "╡░░░░░░╞")
    self.scrollUpButton:display()
    self.scrollDnButton:display()
  else
    self.scrollUpButton:hide()
    self.scrollDnButton:hide()
    gpu.set(3, 40, "════════")
    gpu.set(30, 40, "════════")
  end
  self.display()
end

function GateEntriesWindow.display()
  local self = GateEntriesWindow
  if #gateEntries == 0 then alert("WARNING: NO ADDRESSES IN DATABASE!", 2) end
  gpu.fill(2, 3, 37, 37, " ")
  self.currentIndices = {}
  local displayCount = 0
  local top
  local bot
  if self.mode == "database" then
    top = self.range.top
    bot = self.range.bot
  elseif self.mode == "history" then
    top = self.range.topH
    bot = self.range.botH
  end
  for i,v in ipairs(self.entryStrings) do
    if i >= bot and i <= top then
      displayCount = displayCount + 1
      self.currentIndices[displayCount] = i
      -- gpu.set(3, 2+displayCount, tostring(i)) -- Display Number
      if i == self.selectedIndex then
        gpu.setBackground(0x878787)
      end
      -- gpu.set(7, 2+displayCount, v) -- Old Position
      if self.canDial[i] == false then
        gpu.setForeground(0xB4B4B4)
      end
      gpu.set(3, 2+displayCount, v)
      gpu.setBackground(0x000000)
      if self.mode == "database" then
        if gateEntries[i].fave ~= nil and gateEntries[i].fave == true then
          gpu.setForeground(0xFFFF00)
        else
          gpu.setForeground(0xB4B4B4)
        end
        gpu.set(37, 2+displayCount, "*")
        if i == 1 or gateEntries[i].fave ~= gateEntries[i-1].fave then
          gpu.setForeground(0x0F0F0F)
        else
          gpu.setForeground(0xFFFFFF)
        end
        gpu.set(33, 2+displayCount, "⇧ ") -- Move Up Arrow
        if i == #self.entryStrings or gateEntries[i].fave ~= gateEntries[i+1].fave then
          gpu.setForeground(0x0F0F0F)
        else
          gpu.setForeground(0xFFFFFF)
        end
        gpu.set(35, 2+displayCount, "⇩ ") -- Move Down Arrow
      end
      gpu.setForeground(0xFFFFFF)
    end
  end
  if bot <= 1 then
    self.scrollUpButton:disable(true)
  else
    self.scrollUpButton:disable(false)
  end
  if top >= #self.entryStrings then
    self.scrollDnButton:disable(true)
  else
    self.scrollDnButton:disable(false)
  end

  -- gpu.fill(1, 42, 23, 1, "░") -- For Debug
  -- gpu.set(1, 42, tostring(gateEntries[self.selectedIndex])) -- For Debug
end

function GateEntriesWindow.addressInfo()
  local self = GateEntriesWindow
  if gateRingDisplay.isActive == false then return end
  gpu.fill(42,5,35,2," ")
  if self.selectedIndex ~= nil and self.selectedIndex > 1 then
    local gateEntry = nil
    if self.mode == "database" then
      gateEntry = gateEntries[self.selectedIndex]
    elseif self.mode == "history" then
      gateEntry = historyEntries[self.selectedIndex]
    end
    local gateAddress = gateEntry.gateAddress[GateType]
    if gateAddress ~= nil and #gateAddress > 0 then
      local requirement = sg.getEnergyRequiredToDial(table.unpack(gateAddress))
      if type(requirement) == "table" then
        local storedEnergy = sg.getEnergyStored()
        local operatingTicks = (storedEnergy - requirement.open) / requirement.keepAlive
        local operatingSeconds = math.floor(operatingTicks / 20)
        gpu.set(42, 5, "Energy to Dial:   ")
        if requirement.canOpen == false then
          gpu.setForeground(0xFF0000) -- Red
        elseif operatingSeconds < 10 then
          gpu.setForeground(0xFFFF00) -- Yellow
        else
          gpu.setForeground(0x00FF00) -- Green
        end
        gpu.set(60, 5, requirement.open.." RF")
        gpu.setForeground(0xFFFFFF) -- White
        gpu.set(42, 6, "Keep Open Energy: ")
        if operatingSeconds < 2 then
          gpu.setForeground(0xFF0000) -- Red
        elseif operatingSeconds < 5 then
          gpu.setForeground(0xFF6D00) -- Orange
        elseif operatingSeconds < 10 then
          gpu.setForeground(0xFFFF00) -- Yellow
        else
          gpu.setForeground(0x00FF00) -- Green
        end
        gpu.set(60, 6 , requirement.keepAlive.." RF/t")
        gpu.setForeground(0xFFFFFF) -- White
      else
        gpu.setForeground(0xFF0000) -- Red
        gpu.set(42, 5, "No Gate Detected at Address")
        gpu.setForeground(0xFFFFFF) -- White
      end
    end
  end
end

function GateEntriesWindow.touch(x, y)
  local self = GateEntriesWindow
  if x >= self.xPos and x <= 38 and y >= self.yPos and y <= 40 then
    if not ComputerDialingInterlocked and not addAddressMode and not editGateEntryMode then
      self.selectedIndex = self.currentIndices[y - 2]
      if self.selectedIndex == nil then self.selectedIndex = 0 end
      if (x == 33 or x== 35 or x == 37) and self.mode == "database" then
        self.changePosition(x, y)
      end
      self.addressInfo()
      self.display()
      updateButtons()
      if self.selectedIndex ~= 0 then
        local gateEntry = nil
        if self.mode == "database" then
          gateEntry = gateEntries[self.selectedIndex]
        else
          gateEntry = historyEntries[self.selectedIndex]
        end
        if not gateEntry.AdminOnly or #AdminList == 0 then
          glyphListWindow.insertAddress(gateEntry.gateAddress[GateType])
        else
          glyphListWindow.selectedGlyphs = {}
          glyphListWindow.display()
        end
      end
    end
  elseif ((x >= 3 and x <= 13) or (x >= 31 and x <= 37)) and y == 2 then
    if x >= 3 and x <= 13 then
      self.mode = "database"
    elseif x >= 31 and x <= 37 and isAuthorized(User, AdminOnlySettings.History) then
      self.mode = "history"
    end
    self.selectedIndex = 0
    self.addressInfo()
    updateButtons()
    self.update()
  end
end

function GateEntriesWindow.changePosition(x, y)
  local self = GateEntriesWindow
  local wasInserted = false
  if x == 33 then
    if self.selectedIndex == 1 or gateEntries[self.selectedIndex].fave ~= gateEntries[self.selectedIndex-1].fave then
      return
    else
      -- alert("Going Up", 1) -- For Debug
      local entryBuf = table.remove(gateEntries, self.selectedIndex)
      table.insert(gateEntries, self.selectedIndex-1, entryBuf)
      self.selectedIndex = self.selectedIndex-1
      wasInserted = true
    end
  elseif x == 35 then
    if self.selectedIndex == #self.entryStrings or gateEntries[self.selectedIndex].fave ~= gateEntries[self.selectedIndex+1].fave then
      return
    else
      -- alert("Going Down", 1) -- For Debug
      gpu.set(x, y, "⇩") -- Move Down Arrow
      local entryBuf = table.remove(gateEntries, self.selectedIndex)
      table.insert(gateEntries, self.selectedIndex+1, entryBuf)
      self.selectedIndex = self.selectedIndex+1
      wasInserted = true
    end
  elseif x == 37 then
    local entryBuf = table.remove(gateEntries, self.selectedIndex)
    if entryBuf.fave == nil or entryBuf.fave == false then
      entryBuf.fave = true
    else
      entryBuf.fave = false
    end
    for i,v in ipairs(gateEntries) do
      if v.fave == nil or v.fave == false then
        table.insert(gateEntries, i, entryBuf)
        self.selectedIndex = i
        wasInserted = true
        break
      end
    end
    if not wasInserted then
      table.insert(gateEntries, entryBuf)
      self.selectedIndex = #gateEntries
      wasInserted = true
    end
  end
  if wasInserted then
    self.update()
    writeToDatabase()
  end
end
-- End of Gate Entries Window ------------------------------------------------------

-- Glyph List Window ---------------------------------------------------------------
glyphListWindow = {xPos=term.window.width, yPos=2, width=0, height=0, locked=false}
function glyphListWindow.initialize(glyphType)
  local self = glyphListWindow
  self.glyphType = glyphType
  self.glyphs = nil
  self.selectedGlyphs = {}
  if glyphType == "MW" then
    self.glyphs = GlyphsMW
  elseif glyphType == "UN" then
    self.glyphs = {}
    for i=1,36,1 do
      if i ~= 17 then table.insert(self.glyphs, "Glyph "..i) end
    end
  elseif glyphType == "PG" then
    self.glyphs = GlyphsPG
  end
  gpu.fill(self.xPos-self.width, self.yPos, 2*self.width, term.window.height-8, " ")
  self.width = 1
  self.xPos = term.window.width
  for i,v in ipairs(self.glyphs) do
    if unicode.len(v)+2 > self.width then self.width = unicode.len(v)+2 end
  end
  if self.width < 12 then self.width = 12 end
  if self.xPos+self.width-1 > term.window.width then self.xPos = term.window.width-self.width+1 end
  self.glyphsHeight = #self.glyphs
  self.height = 4+self.glyphsHeight
  buttons.glyphResetButton.xPos = self.xPos-self.width
  gpu.set(self.xPos, self.yPos, "╓")
  gpu.fill(self.xPos+1, self.yPos, self.width-2, 1, "─")
  gpu.set(self.xPos+self.width-1, self.yPos, "╖")
  gpu.set(self.xPos, self.yPos+1, "║")
  gpu.set(self.xPos+self.width-1, self.yPos+1, "║")
  gpu.set(self.xPos, self.yPos+2, "╠")
  gpu.fill(self.xPos+1, self.yPos+2, self.width-2, 1, "═")
  gpu.set(self.xPos+self.width-1, self.yPos+2, "╣")
  gpu.fill(self.xPos, self.yPos+3, 1, self.glyphsHeight, "║")
  gpu.fill(self.xPos+self.width-1, self.yPos+3, 1, self.glyphsHeight, "║")
  gpu.set(self.xPos, self.yPos+3+self.glyphsHeight, "╚")
  gpu.fill(self.xPos+1, self.yPos+3+self.glyphsHeight, self.width-2, 1, "═")
  gpu.set(self.xPos+self.width-1, self.yPos+3+self.glyphsHeight, "╝")
  gpu.set(self.xPos, self.yPos+3, "╢")
  self.display()
end

function glyphListWindow.display()
  local self = glyphListWindow
  local oStr = ""
  if self.glyphType == "MW" then
    oStr = "Origin"
  elseif self.glyphType == "UN" then
    oStr = "Glyph 17"
  elseif self.glyphType == "PG" then
    oStr = "Subido"
  end
  local yOffset = self.yPos + 2
  local xOffset = self.xPos-self.width
  local resetButton = buttons.glyphResetButton
  resetButton.xPos = xOffset+(self.width/2-resetButton.width/2)
  gpu.fill(self.xPos+1, yOffset+1, self.width-2, self.glyphsHeight, " ")
  gpu.fill(xOffset+1, 7, self.width-2, 8, " ")
  for i,v in ipairs(self.selectedGlyphs) do
    if v == -1 then gpu.setBackground(0x878787) end
  end
  gpu.set(self.xPos+(self.width/2-unicode.len(oStr)/2), self.yPos+1, oStr)
  gpu.setBackground(0x000000)
  for i,v in ipairs(self.glyphs) do
    for i2,v2 in ipairs(self.selectedGlyphs) do
      if i == v2 then gpu.setBackground(0x878787) end
    end
    if v == "Orion" or v == "Urion" then v = "Orion" end
    gpu.set(self.xPos+(self.width/2-unicode.len(v)/2), yOffset+i, tostring(v))
    gpu.setBackground(0x000000)
  end
  if #self.selectedGlyphs > 0 then
    if not self.locked then
      resetButton:display()
    end
    gpu.setForeground(0xFFFFFF)
  else
    resetButton:hide()
    gpu.setForeground(0x0F0F0F)
  end
  gpu.set(xOffset, yOffset+2, "┌")
  gpu.fill(xOffset+1, yOffset+2, self.width-2, 1, "─")
  gpu.set(xOffset+self.width-1, yOffset+2, "┐")
  gpu.set(xOffset+(self.width/2)-1, yOffset+2, "┴")
  gpu.set(xOffset+(self.width/2)-1, yOffset+1, "┌")
  gpu.fill(xOffset+(self.width/2), yOffset+1, (self.width/2), 1, "─")
  if gateRingDisplay.isActive then
    gpu.fill(xOffset, yOffset+3, 1, 8, "┤")
  else
    gpu.fill(xOffset, 3, self.width, 1, " ")
    gpu.fill(xOffset, yOffset+3, 1, 8, "│")
  end
  gpu.fill(xOffset+self.width-1, yOffset+3, 1, 8, "│")
  gpu.set(xOffset, yOffset+11, "└")
  gpu.fill(xOffset+1, yOffset+11, self.width-2, 1, "─")
  gpu.set(xOffset+self.width-1, yOffset+11, "┘")
  for i,v in ipairs(self.selectedGlyphs) do
    local glyph = self.glyphs[v]
    -- if v ~= -1 then gpu.set(xOffset+(self.width/2-unicode.len(glyph)/2), yOffset+2+i, glyph) end

    if v == -1 and (#self.selectedGlyphs < 7 or i < #self.selectedGlyphs) then
      glyph = oStr
      gpu.setForeground(0xFF0000)
    elseif v == -2 then
      glyph = "Unknown"
      gpu.setForeground(0xFF0000)
    end
    if glyph ~= nil and i < 9 then gpu.set(xOffset+(self.width/2-unicode.len(glyph)/2), yOffset+2+i, glyph) end
    gpu.setForeground(0xFFFFFF)
  end
  gpu.setForeground(0xFFFFFF)
end

function glyphListWindow.touch(x,y)
  local self = glyphListWindow
  if not ComputerDialingInterlocked and not dialerAdrEntryMode and not self.locked then
    if x > self.xPos and x < self.xPos+self.width-1 and y > self.yPos and y < self.yPos+self.height-1 then
      local selection = y-self.yPos-2
      local newSelection = true
      for i,v in ipairs(self.selectedGlyphs) do
        if selection == v then newSelection = false end
      end
      if newSelection and #self.selectedGlyphs < 9 then
        if selection > 0 and #self.selectedGlyphs < 8 then
          table.insert(self.selectedGlyphs, selection)
        end
        self.display()
        if selection == -1 then
          AddressBuffer = {}
          local glyph = ""
          for i,v in ipairs(self.selectedGlyphs) do
            if v ~= -1 then
              glyph = self.glyphs[v]
              if self.glyphType == "UN" then _,glyph = checkGlyph(glyph, "UN") end
              table.insert(AddressBuffer, glyph)
            end
          end
          if #AddressBuffer >= 6 then
            if addAddressMode then
              GoodAddress = true
              -- manualAdrEntryMode = false
              -- completeAddressEntry(self.glyphType)
            else
              directDial()
            end
            self.display()
          elseif #AddressBuffer < 6 then
            AddressBuffer = {}
            self.display()
            alert("ADDRESS IS TOO SHORT", 2)
          end
        end
      end
    end
  end
end

function glyphListWindow.insertGlyph(glyph)
  if IncomingWormhole then return end
  if GateType == "UN" and glyph:sub(1, 5) ~= "Glyph" then
    glyph = string.gsub(glyph, "G", "Glyph ")
  end
  if glyph == "Glyph 17" or glyph == "Point of Origin" or glyph == "Subido" then table.insert(glyphListWindow.selectedGlyphs, -1) end
  if glyph == "Unknown" then table.insert(glyphListWindow.selectedGlyphs, -2) end
  for i2,v2 in ipairs(glyphListWindow.glyphs) do
    if glyph == v2 then table.insert(glyphListWindow.selectedGlyphs, i2) end
  end
  glyphListWindow.display()
end

function glyphListWindow.insertAddress(address)
  glyphListWindow.selectedGlyphs = {}
  if type(address) == "table" and #address > 0 then
    for i,glyph in ipairs(address) do
      if GateType == "UN" and glyph:sub(1, 5) ~= "Glyph" then
        glyph = string.gsub(glyph, "G", "Glyph ")
      end
      if glyph == "Glyph 17" or glyph == "Point of Origin" or glyph == "Subido" then table.insert(glyphListWindow.selectedGlyphs, -1) end
      if glyph == "Unknown" then table.insert(glyphListWindow.selectedGlyphs, -2) end
      for i2,v2 in ipairs(glyphListWindow.glyphs) do
        if glyph == v2 then table.insert(glyphListWindow.selectedGlyphs, i2) end
      end
    end
  end
  glyphListWindow.display()
end

function glyphListWindow.showAddress()
  DialedAddress = parseAddressString(sg.dialedAddress, GateType)
  if #DialedAddress ~= #glyphListWindow.selectedGlyphs then
  -- if #DialedAddress > #glyphListWindow.selectedGlyphs then
    glyphListWindow.selectedGlyphs = {}
    for i,v in ipairs(DialedAddress) do
      glyphListWindow.insertGlyph(v)
    end
  end
  -- local str = ""
  -- for i,v in ipairs(glyphListWindow.selectedGlyphs) do
    -- str = str.."  "..tostring(v)
  -- end
  -- alert(str, 2)
end

function glyphListWindow.reset()
  local self = glyphListWindow
  self.selectedGlyphs = {}
  buttons.glyphResetButton:hide()
  self.display()
  if not editGateEntryMode then
    GateEntriesWindow.selectedIndex = 0
  end
  GateEntriesWindow.display()
  updateButtons()
end
-- End of Glyph List Window -------------------------------------------------------------

-- Direct Dialing -----------------------------------------------------------------------
function directDial()
  local glyph = ""
  if not isDirectDialing then isDirectDialing = true end
  local directEntry = {name="Direct Dial", gateAddress={}}
  directEntry.gateAddress[GateType] = AddressBuffer
  if #AddressBuffer < 6 then
    alert("ENTERED ADDRESS TOO SHORT", 2)
  else
    dialAddress(directEntry, 0)
  end
  isDirectDialing = false
end
-- End of Direct Dialing ----------------------------------------------------------------

-- Address Dialing ----------------------------------------------------------------------
function dialAddress(gateEntry, num)
  if gateEntry == nil then
    alert("NO GATE ENTRY SELECTED", 2)
    return
  end
  if sg.getGateStatus() == "open" then
    alert("CAN NOT DIAL DUE TO STARGATE BEING OPEN", 2)
    return
  end
  if sg.getGateStatus() ~= "idle" or sg.dialedAddress ~= "[]" then
    alert("CAN NOT DIAL DUE TO EXISTING GATE ACTIVITY", 2)
    return
  end
  local localAddress = nil
  if GateType == "MW" then localAddress = localMWAddress
  elseif GateType == "UN" then localAddress = localUNAddress
  elseif GateType == "PG" then localAddress = localPGAddress
  end
  if gateEntry.gateAddress[GateType] == nil or #gateEntry.gateAddress[GateType] == 0 then
    alert("CAN NOT DIAL DUE TO NO GATE ADDRESS ENTRY", 2)
    return
  end
  AddressBuffer = {}
  for i,v in ipairs(gateEntry.gateAddress[GateType]) do table.insert(AddressBuffer, v) end
  -- local requirement, msg = sg.getEnergyRequiredToDial(AddressBuffer) -- Broken in Lua 5.3
  local requirement, msg = sg.getEnergyRequiredToDial(table.unpack(AddressBuffer)) -- Temp Workaround
  if type(requirement) == "string" then
    if requirement == "address_malformed" then
      if entriesDuplicateCheck(localAddress, {gateEntry}, GateType, 1) then
        alert("GATE CAN NOT DIAL ITSELF", 2)
      else
        alert("NO GATE FOUND AT PROVIDED ADDRESS", 2)
      end
    end
    return
  elseif type(requirement) == "table" then
    if requirement.canOpen == false then
      alert("NOT ENOUGH POWER TO OPEN ... "..tostring(requirement.open).." RF NEEDED", 2)
      return
    end
  else
    alert(tostring("\""..msg.."\" RETURNED FROM getEnergyRequiredToDial()"), 3)
    return
  end
  -- Smart Dialing --
  if #AddressBuffer > 6 then
    local shorterAdr = {}
    for i=1,6 do table.insert(shorterAdr, AddressBuffer[i]) end
    for i=7,8 do
      requirement, msg = sg.getEnergyRequiredToDial(table.unpack(shorterAdr))
      if type(requirement) == "table" then
        alert("SMART DIALING ACTIVE", 1)
        break
      else
        table.insert(shorterAdr, AddressBuffer[i])
      end
    end
    AddressBuffer = {}
    for i,v in ipairs(shorterAdr) do table.insert(AddressBuffer, v) end
  end
  -- End of Smart Dialing --
  if GateType == "MW" then
    table.insert(AddressBuffer,"Point of Origin")
  elseif GateType == "UN" then
    table.insert(AddressBuffer,"Glyph 17")
  elseif GateType == "PG" then
    table.insert(AddressBuffer,"Subido")
  end
  if gateEntry.IDC ~= nil then
    OutgoingIDC = gateEntry.IDC
  end
  -- Preparing to Dial --
  clearDisplay()
  HelpButton:disable(true)
  gateRingDisplay.draw()
  glyphListWindow.reset()
  buttons.abortDialingButton:disable(false)
  buttons.abortDialingButton:display()
  ComputerDialingInterlocked = true
  AbortingDialing = false
  glyphListWindow.locked = true
  DialingPaused = false
  ChildThread.computerDialing = thread.create(dialNext, 0)
  -- dialNext(0)
end

function dialNext(dialed)
  while DialingPaused do os.sleep(0.05) end
  if not AbortingDialing then
    -- dialAddressWindow.display(gateEntry) --Deprecated?!
    local glyph = AddressBuffer[dialed + 1]
    -- dialAddressWindow.glyph = glyph --Deprecated?!
    if component.isAvailable("dhd") and GateType ~= "UN" and (MiscSettings.dialWithDHD or ForceDialDHD) then
      ComputerDialingWithDHD = true
    end
    glyphListWindow.insertGlyph(glyph)
    if (dialed+1) < 7 then
      gateRingDisplay.traces(dialed+1, 1)
    elseif (dialed+1) == #AddressBuffer then
      gateRingDisplay.traces(7, 1)
      buttons.abortDialingButton:disable(true)
    else
      gateRingDisplay.traces(dialed+2, 1)
    end
    if dialed == 0 or ComputerDialingWithDHD then -- and GateType ~= "PG") then
      gateRingDisplay.glyphImage(glyph)
    else
      event.timer(0.5, function() gateRingDisplay.glyphImage(glyph) end)
    end
    if ComputerDialingWithDHD then
      local _,result,msg = component.dhd.pressButton(glyph)
      if result ~= "dhd_pressed" then
        if result == "dhd_not_connected" then
          computer.pushSignal("stargate_failed","",true,result)
        else
          component.dhd.pressBRB()
        end
        os.exit() -- Only the thread exits, AGS continues to run.
      end
      if GateType == "PG" or not MiscSettings.LudicrousSpeed then
        os.sleep(0.05)
        while sg.getGateStatus() == "dialing" do os.sleep() end
      end
      if (dialed + 1) == #AddressBuffer then
        local _,result,msg = component.dhd.pressBRB()
        if result == "dhd_engage" then
          os.sleep(1)
          gateRingDisplay.eventHorizon(true)
        end
      else
        gateRingDisplay.dialedChevrons(dialed+1, true)
        dialNext(dialed+1)
      end
    else
      sg.engageSymbol(glyph)
    end
  end
end

function finishDialing()
  if ComputerDialingInterlocked then
    ComputerDialingInterlocked = false
    ComputerDialingWithDHD = false
    ForceDialDHD = false
    isDirectDialing = false
    gpu.fill(41, 2, 38, 5, " ")
    mainInterface("noClear")
  end
end

local function IncomingWormholeAbortDialing()
  pcall(function() ChildThread.computerDialing:kill() end)
  finishDialing()
end

local function directAbortDialing()
  if ChildThread.computerDialing ~= nil then ChildThread.computerDialing:kill() end
  local abortResult = ""
  while abortResult ~= "stargate_aborting" do
    _,abortResult = sg.abortDialing()
  end
  -- sg.abortDialing()
  -- if AbortingDialing then
    -- if GateType == "UN" then
      -- alert("ABORTING DIALING... PLEASE WAIT", 2)
      -- while sg.getGateStatus() == "dialing_computer" do os.sleep() end
    -- end
    -- alert("DIALING ABORTED", 2)
  -- end

  if GateType ~= "UN" then
    gateRingDisplay.glyphImage()
    gateRingDisplay.reset()
    if DialingInterlocked then DialingInterlocked = false end
    finishDialing()
    glyphListWindow.locked = false
    glyphListWindow.display()
    AbortingDialing = false
  end
  alert("DIALING ABORTED", 2)
end

function abortDialing()
  if DialingPaused then
    alert("Can Not Abort While Dialing is Paused",2)
    return
  end
  AbortingDialing = true
  buttons.abortDialingButton:disable(true)
  -- if sg.abortDialing ~= nil and GateType ~= "UN" then
  if sg.abortDialing ~= nil then
    directAbortDialing()
  else
    alert("ABORTING DIALING... PLEASE WAIT", 2)
    while sg.getGateStatus() ~= "idle" do os.sleep() end
    alert("DIALING ABORTED", 2)
    sg.engageGate()
    while sg.getGateStatus() == "failing" do os.sleep() end
    ComputerDialingInterlocked = false
    AbortingDialing = false
    gpu.fill(41, 2, 38, 5, " ")
    mainInterface("noClear")
  end
end
-- End Address Dialing -------------------------------------------------------------

-- Address Entry -------------------------------------------------------------------
local AddressEntry = {}
AddressEntry.entryAccepted = nil
AddressEntry.yesButton = Button.new(92, 8, 0, 0, "Yes", function() AddressEntry.entryAccepted = true end)
AddressEntry.noButton = Button.new(98, 8, 0, 0, "No", function() AddressEntry.entryAccepted = false end)

local function addNewGateEntry()
  table.insert(gateEntries, {name="New Entry",gateAddress={MW={},PG={},UN={}},fave=false})
  GateEntriesWindow.selectedIndex = #gateEntries
  writeToDatabase()
  editGateEntry(GateEntriesWindow.selectedIndex)
  alert("Please Enter a Name for the New Gate Entry", 1)
  buttons.renameButton:forceTouch()
end

local function completeAddressEntry(adrType)
  clearDisplay()
  buttons.cancelButton:display()
  glyphListWindow.locked = true
  local index = nil
  local addressName = ""
  local isDuplicate, duplicateNames = entriesDuplicateCheck(AddressBuffer, gateEntries, adrType, 1)
  if editGateEntryMode then index = GateEntriesWindow.selectedIndex end
  if index ~= nil and index > 0 then addressName = gateEntries[index].name end
  for i,v in ipairs(duplicateNames) do
    if v == addressName then table.remove(duplicateNames, i) end
  end
  if #duplicateNames == 0 then isDuplicate = false end
  if isDuplicate then
    alert("ATTENTION",2)
    gpu.set(42, 6, "Possible duplicate address with the following gate entries:")
    term.setCursor(42, 7)
    for i,v in ipairs(duplicateNames) do
      io.write("'"..v.."'")
      if i ~= #duplicateNames then io.write(", ") end
    end
    gpu.set(42, 9, "Would you still like to have the address entered?")
    term.setCursor(104, 8)
    AddressEntry.yesButton:display()
    AddressEntry.noButton:display()
    AddressEntry.entryAccepted = nil
    while AddressEntry.entryAccepted == nil and not WasCanceled do
      os.sleep(0.05)
    end
    AddressEntry.yesButton:hide()
    AddressEntry.noButton:hide()
    if not AddressEntry.entryAccepted then
      alert("ADDRESS ENTRY CANCELED", 1)
    end
  else
    AddressEntry.entryAccepted = true
  end
  if AddressEntry.entryAccepted then
    gateEntries[index].gateAddress[adrType] = {}
    for i,v in ipairs(AddressBuffer) do table.insert(gateEntries[index].gateAddress[adrType], v) end
    writeToDatabase()
    alert("ADDRESS HAS BEEN UPDATED", 1)
  end
  glyphListWindow.locked = false
  addAddressMode = false
  manualAdrEntryMode = false
  editGateEntry(index)
end

local function manualAddressEntry()
  manualAdrEntryMode = true
  GoodAddress = false
  glyphListWindow.locked = false
  clearDisplay()
  buttons.cancelButton:display()
  if glyphListWindow.glyphType ~= adrEntryType then
    glyphListWindow.initialize(adrEntryType)
  else
    glyphListWindow.display()
  end
  local oStr = ""
  if glyphListWindow.glyphType == "MW" then
    oStr = "Origin"
  elseif glyphListWindow.glyphType == "UN" then
    oStr = "Glyph 17"
  elseif glyphListWindow.glyphType == "PG" then
    oStr = "Subido"
  end
  gpu.set(42, 6, "Enter the address using the glyphs to the right. Then hit '"..oStr.."' to complete.")
  while not GoodAddress and manualAdrEntryMode and not WasCanceled do
    os.sleep(0.05)
  end
  if GoodAddress then
    completeAddressEntry(adrEntryType)
  end
  manualAdrEntryMode = false
  glyphListWindow.initialize(GateType)
end

local function addressEntry(adrType)
  addAddressMode = true;
  adrEntryType = adrType
  AddressBuffer = {}
  clearDisplay()
  buttons.cancelButton:display()
  if adrType ~= GateType then
    -- manualAddressEntry()
    ChildThread.manualAddressEntry = thread.create(manualAddressEntry)
    return
  end
  gpu.set(42, 6, "Select one of the below options to enter the address.")
  buttons.manualEntryButton:display()
  if GateType == "MW" or GateType == "PG" then
    buttons.dhdEntryButton:display()
  elseif GateType == "UN" then
    buttons.dialerEntryButton:display()
  end
end

local function dhdAddressEntry()
  DHD_AdrEntryMode = true
  GoodAddress = false
  WasCanceled = false -- Redundant?
  clearDisplay()
  buttons.cancelButton:display()
  glyphListWindow.reset()
  gpu.set(42, 6, "Use the DHD to dial the glyphs of the address, excluding the 'Point of Origin'.")
  if GateType == "MW" then
    gpu.set(42, 7, "Then hit the 'Big Red Button'")
  elseif GateType == "PG" then
    gpu.set(42, 7, "Then hit the 'Big Blue Button'")
  end
  while DHD_AdrEntryMode and not WasCanceled and not GoodAddress do
    os.sleep(0.05)
  end
  if GoodAddress then
    AddressBuffer = {}
    local glyph = ""
    for i,v in ipairs(glyphListWindow.selectedGlyphs) do
      if v ~= -1 then
        glyph = glyphListWindow.glyphs[v]
        if GateType == "UN" then _,glyph = checkGlyph(glyph, "UN") end
        table.insert(AddressBuffer, glyph)
      end
    end
    completeAddressEntry(GateType)
  end
  addAddressMode = false
  DHD_AdrEntryMode = false
end

local function dialerAddressEntry()
  local allGood = true
  local dialing = false
  clearDisplay()
  glyphListWindow.reset()
  buttons.cancelButton:display()
  dialerAdrEntryMode = true
  gpu.fill(41, 6, 91, 10, " ")
  gpu.set(42, 6, "Dial the gate using your Universe Dialer. The address will be captured once the gate opens.")
  gpu.setForeground(0xFFFF00)
  gpu.set(42, 7, "Warning this process will use power since the gate will open.")
  gpu.set(42, 8, "The gate will close automatically after address capture.")
  gpu.setForeground(0xFFFFFF)
  gpu.set(42, 9, "Please begin dialing or push 'Cancel'")
  while dialerAdrEntryMode do
    os.sleep(0.05)
    if WasCanceled then
      allGood = false
      WasCanceled = false
      dialerAdrEntryMode = false
    end
    if not dialing and sg.getGateStatus() == "dialing" then dialing = true end
    if dialing and not UNGateResetting then
      alert("PLEASE WAIT", 0)
      if sg.getGateStatus() == "idle" then
        alert("DIALING WAS ABORTED", 2)
        dialing = false
        -- allGood = false
        -- dialerAdrEntryMode = false
      elseif sg.getGateStatus() == "open" then -- (Backup check of Opening Event)
        event.timer(1, function() sg.disengageGate() end, 3)
        dialerAdrEntryMode = false
      end
    end
  end
  if allGood then
    AddressBuffer = {}
    for i,v in ipairs(glyphListWindow.selectedGlyphs) do
      if v ~= -1 then
        glyph = glyphListWindow.glyphs[v]
        table.insert(AddressBuffer, glyph)
      end
    end
    alert("ADDRESS WAS CAPTURED", 1)
    completeAddressEntry("UN")
    addAddressMode = false
  end
  dialerAdrEntryMode = false
end
-- End of Address Entry ------------------------------------------------------------

-- Edit Gate Entry -----------------------------------------------------------------
local GateEntryEdit = {}
GateEntryEdit.adminCheckBox = CheckBox.new(109, 6, {}, "NotUsed", function()
  local gateEntry = gateEntries[GateEntriesWindow.selectedIndex]
  if #AdminList == 0 then
    alert("Admin List Needs to Be Setup to Use This Option", 2)
  elseif isAuthorized(User) then
    gateEntry.AdminOnly = (not gateEntry.AdminOnly)
    writeToDatabase()
  end
  GateEntryEdit.adminCheckBox.isChecked = (gateEntry.AdminOnly)
end)
buttons.GEE_adminCheckBox = GateEntryEdit.adminCheckBox

function editGateEntry(index)
  local gateEntry = gateEntries[index]
  -- if gateEntry == nil then
    -- alert("SELECT A GATE ENTRY TO EDIT", 2)
    -- mainInterface()
    -- return
  -- end
  editGateEntryMode = true
  clearDisplay()
  HelpButton:disable(true)
  buttons.cancelButton:display()
  buttons.renameButton:display()
  buttons.changeEntryIDCButton:display()
  buttons.deleteButton:display()
  if type(gateEntry.AdminOnly) ~= "boolean" then gateEntry.AdminOnly = false end
  GateEntryEdit.adminCheckBox:display(gateEntry.AdminOnly)
  glyphListWindow.display()
  glyphListWindow.locked = true
  if gateEntry.gateAddress.MW == nil then gateEntry.gateAddress["MW"] = {} end
  if gateEntry.gateAddress.UN == nil then gateEntry.gateAddress["UN"] = {} end
  if gateEntry.gateAddress.PG == nil then gateEntry.gateAddress["PG"] = {} end
  gpu.set(42, 6, "Name:")
  gpu.set(73, 6, "IDC:")
  gpu.set(91, 6, "Admin Only Access")
  gpu.setBackground(0x878787)
  gpu.fill(48, 6, 21, 1, " ")
  gpu.fill(78, 6, 9, 1, " ")
  gpu.set(48, 6, gateEntry.name)
  if gateEntry.IDC ~= nil then gpu.set(78, 6, tostring(gateEntry.IDC)) end
  gpu.setBackground(0x000000)
  gpu.set(41, 7, "┌────────────────┐  ┌────────────────┐  ┌────────────────┐")
  gpu.set(41, 8, "│   ░░░░░░░░░    │  │    ░░░░░░░░    │  │    ░░░░░░░     │")
  gpu.set(41, 9, "├────────────────┤  ├────────────────┤  ├────────────────┤")
  buttons.addressEntry_MW_Button.border = false
  buttons.addressEntry_UN_Button.border = false
  buttons.addressEntry_PG_Button.border = false
  buttons.addressEntry_MW_Button:display(44, 7)
  buttons.addressEntry_UN_Button:display(65, 7)
  buttons.addressEntry_PG_Button:display(85, 7)
  gpu.fill(41, 10, 1, 8, "│")
  gpu.fill(58, 10, 1, 8, "│")
  gpu.fill(61, 10, 1, 8, "│")
  gpu.fill(78, 10, 1, 8, "│")
  gpu.fill(81, 10, 1, 8, "│")
  gpu.fill(98, 10, 1, 8, "│")
  gpu.set(41, 18, "└────────────────┘  └────────────────┘  └────────────────┘")
  -- gpu.set(49, 19, "To change an address click on its name.")
  gpu.set(42, 19, "To change the entry Name or IDC, directly click on their")
  gpu.set(42, 20, "text field. To change an address click on its name.")
  for i,v in ipairs(gateEntry.gateAddress.MW) do
    gpu.set(41+(9-math.floor(unicode.len(v)/2)), 9+i, v)
  end
  for i,v in ipairs(gateEntry.gateAddress.UN) do
    gpu.set(61+(9-math.ceil(unicode.len(v)/2)), 9+i, v)
  end
  for i,v in ipairs(gateEntry.gateAddress.PG) do
    gpu.set(81+(8-math.floor(unicode.len(v)/2)), 9+i, v)
  end
  if #gateEntry.gateAddress.MW == 0 then gpu.fill(42, 10, 16, 8, "░") end
  if #gateEntry.gateAddress.UN == 0 then gpu.fill(62, 10, 16, 8, "░") end
  if #gateEntry.gateAddress.PG == 0 then gpu.fill(82, 10, 16, 8, "░") end
end

local function renameGateEntry(index)
  buttons.deleteButton:disable(true)
  local oldName = gateEntries[index].name
  local newName, successful = userInput(48, 6, 21, true)
  if successful then
    if newName ~= "" then
      gateEntries[index].name = newName
      alert("\""..oldName.."\" HAS BEEN RENAMED TO \""..gateEntries[index].name.."\"", 1)
      writeToDatabase()
    end
  end
  buttons.deleteButton:disable(false)
  if editGateEntryMode then
    gpu.setBackground(0x878787)
    gpu.fill(48, 6, 21, 1, " ")
    gpu.set(48, 6, gateEntries[index].name)
    gpu.setBackground(0x000000)
  end
end

local function changeEntryIDC(index)
  buttons.deleteButton:disable(true)
  local newIDC, successful = userInput(78, 6, 9, true)
  if successful then
    if newIDC == "" then
      alert("IDC Was Cleared", 2)
      gateEntries[index].IDC = nil
      writeToDatabase()
    else
      newIDC = tonumber(newIDC)
      if type(newIDC) == "number" and newIDC >= 0 and newIDC < 1e9 and math.floor(newIDC) == newIDC then
        alert("IDC Has Been Changed", 1)
        gateEntries[index].IDC = newIDC
        writeToDatabase()
      else
        alert("Invalid IDC", 2)
      end
    end
  end
  buttons.deleteButton:disable(false)
  if editGateEntryMode then
    gpu.setBackground(0x878787)
    gpu.fill(78, 6, 9, 1, " ")
    if gateEntries[index].IDC ~= nil then gpu.set(78, 6, tostring(gateEntries[index].IDC)) end
    gpu.setBackground(0x000000)
  end
end

local function deleteGateEntry(value)
  buttons.renameButton:disable(true)
  if value == 0 then
    gpu.set(44, 23, "┬─────┬")
    gpu.set(44, 24, "│     │")
    gpu.set(44, 25, "├─────┤")
    gpu.set(44, 26, "│     │")
    gpu.set(44, 27, "└─────┘")
    buttons.deleteYesButton:display()
    buttons.deleteNoButton:display()
  elseif value == 1 then
    local index = GateEntriesWindow.selectedIndex
    alert("GATE ENTRY '"..gateEntries[index].name.."' REMOVED", 1)
    table.remove(gateEntries, index)
    writeToDatabase()
    glyphListWindow.locked = false
    editGateEntryMode = false
    buttons.renameButton:disable(false)
    mainInterface()
  elseif value == -1 then
    gpu.fill(44, 23, 7, 5, " ")
    gpu.set(44, 23, "───────")
    buttons.deleteYesButton:hide()
    buttons.deleteNoButton:hide()
    -- alert("DELETE CANCELED", 1) -- For Debug
    buttons.renameButton:disable(false)
  end
end
-- End Edit Gate Entry -------------------------------------------------------------

-- Gate Ring Display ---------------------------------------------------------------
gateRingDisplay = {}
function gateRingDisplay.initialize()
  local self = gateRingDisplay
  self.isActive = false
  if sg.getGateStatus() == "open" then
    self.eventHorizonState = true
  else
    self.eventHorizonState = false
  end
  self.chevronStates = {}
  self.traceStates = {}
  self.engagedChevronCount = 0
  if GateStatusBool == false then
    for i=1,9 do table.insert(self.chevronStates, true) end
  else
    for i=1,9 do table.insert(self.chevronStates, false) end
  end
  for i=1,9 do table.insert(self.traceStates, 0) end
  dofile("gateRing.ff") -- Loads the gate ring graphics
  if GateType == "MW" then
    dofile("glyphsMW.ff") -- Loads MW Glyph Images
  elseif GateType == "UN" then
    dofile("glyphsUN.ff") -- Loads UN Glyph Images
  elseif GateType == "PG" then
    dofile("glyphsPG.ff") -- Loads UN Glyph Images
  end
  self.ringTbl, self.topTbl, self.midTbl, self.botTbl = {},{},{},{}
  self.chevTbl = {"⢤⣤⣤⣤⣤⡤","⠀⢻⣿⣿⡟","⠀⠀⢻⡟"}
  self.dotTbl = {"⢀⣴⣶⣦⡀","⣿⣿⣿⣿⣿","⠈⠻⠿⠟⠁"}
  self.dot2Tbl = {"⣠⣾⣿⣷⣄", "⢿⣿⣿⣿⡿", "⠙⠛⠋"}
  if GateType == "MW" then
    self.offColor = 0x662400
    -- self.offColor = 0x662400
    self.onColor = 0x994900
    self.ringColor = 0x5A5A5A
    -- self.ringColor = 0x696969
    -- self.ringColor = 0x4B4B4B
    self.horizonColor = 0x006DFF
  elseif GateType == "UN" then
    self.offColor = 0xA5A5A5
    self.onColor = 0xFFFFFF
    self.ringColor = 0x1E1E1E
    self.horizonColor = 0x787878
  elseif GateType == "PG" then
    -- self.offColor = 0x4B4B4B
    self.offColor = 0x000040
    self.onColor = 0x0092FF
    -- self.ringColor = 0x5A5A5A
    self.ringColor = 0x4B4B4B
    -- self.ringColor = 0x696969
    self.horizonColor = 0x006DFF
  else
    self.offColor = 0xA5A5A5
    self.onColor = 0xFFFFFF
    self.ringColor = 0x1E1E1E
    self.horizonColor = 0x787878
  end
  for line in GateRing.wholeRing:gmatch("[^\r\n]+") do table.insert(self.ringTbl, line) end
  for line in GateRing.horizonTop:gmatch("[^\r\n]+") do table.insert(self.topTbl, line) end
  for line in GateRing.horizonMid:gmatch("[^\r\n]+") do table.insert(self.midTbl, line) end
  for line in GateRing.horizonBot:gmatch("[^\r\n]+") do table.insert(self.botTbl, line) end
end

function gateRingDisplay.draw()
  local self = gateRingDisplay
  self.isActive = true
  gpu.setForeground(self.ringColor)
  for i,v in ipairs(self.ringTbl) do
    gpu.set(50, 7+i, v)
  end
  self.eventHorizon()
  self.traces()
end

function gateRingDisplay.glyphImage(glyphName, isEngaged)
  local self = gateRingDisplay
  local xPos = 0
  local yPos = 0
  if GateType == "MW" or GateType == "PG" then
    xPos = 64
    yPos = 15
    gpu.fill(xPos, yPos, 32, 16, " ")
  elseif GateType == "UN" then
    xPos = 77
    yPos = 14
    gpu.fill(xPos, yPos, 6, 18, " ")
  end
  if (glyphName == nil and isEngaged == nil) or glyphName == "Unknown" then return end
  if IncomingWormhole then return end
  if isEngaged then
    gpu.setForeground(self.onColor)
  else
    gpu.setForeground(self.offColor)
  end
  if glyphName ~= nil or glyphName ~= "" then
    local glyphImage = GlyphImages[glyphName]
    for line in glyphImage:gmatch("[^\r\n]+") do
      gpu.set(xPos, yPos, line)
      yPos = yPos + 1
    end
  end
  gpu.setForeground(0xFFFFFF)
end

function gateRingDisplay.traces(num, state)
  local self = gateRingDisplay
  if not self.isActive then return end
  if num == nil or num == -1 then
    for i,v in ipairs(self.traceStates) do self.traces(i, v) end
    return
  end
  local glw = glyphListWindow
  local glyphBoxX = 161 - (2 * glw.width)
  local traceEndOffset = 0
  if glw.width ~= nil then
    traceEndOffset = 2*glw.width
  else
    traceEndOffset = 35
  end
  if state == nil or state == 0 then
    gpu.setForeground(0x0F0F0F)
  elseif state == 1 then
    gpu.setForeground(self.offColor)
  elseif state == 2 then
    gpu.setForeground(self.onColor)
  end
  self.traceStates[num] = state

  if num == 1 then
    gpu.set(93, 8, "┌─┴─┐") -- 1
    gpu.set(95, 7, "┌") -- 1
    gpu.fill(96, 7, 65-traceEndOffset, 1, "─") -- 1
  elseif num == 2 then
    gpu.set(110, 18, "┐├┘", true) -- 2
    gpu.set(111, 19, "─┘") -- 2
    gpu.fill(112, 9, 1, 10, "│") -- 2
    gpu.set(112, 8, "┌") -- 2
    gpu.fill(113, 8, 48-traceEndOffset, 1, "─") -- 2
  elseif num == 3 then
    gpu.set(109, 27, "┐├┘", true) -- 3
    gpu.set(110, 28, "────┘") -- 3
    gpu.fill(114, 10, 1, 18, "│") -- 3
    gpu.set(114, 9, "┌") -- 3
    gpu.fill(115, 9, 46-traceEndOffset, 1, "─") -- 3
  elseif num == 4 then
    gpu.set(50, 27, "┌┤└", true) -- 4
    gpu.set(48, 28, "┌─") -- 4
    gpu.fill(48, 29, 1, 10, "│") -- 4
    gpu.set(48, 39, "└") -- 4
    gpu.fill(49, 39, 20, 1, "─") -- 4
    gpu.fill(70, 39, 20, 1, "─") -- 4
    gpu.fill(91, 39, 25, 1, "─") -- 4
    gpu.set(116, 39, "┘") -- 4
    gpu.fill(116, 11, 1, 28, "│") -- 4
    gpu.set(116, 10, "┌") -- 4
    gpu.fill(117, 10, 44-traceEndOffset, 1, "─") -- 4
  elseif num == 5 then
    gpu.set(49, 18, "┌┤└", true) -- 5
    gpu.set(46, 19, "┌──") -- 5
    gpu.fill(46, 20, 1, 20, "│") -- 5
    gpu.set(46, 40, "└") -- 5
    gpu.fill(47, 40, 22, 1, "─") -- 5
    gpu.fill(70, 40, 20, 1, "─") -- 5
    gpu.fill(91, 40, 27, 1, "─") -- 5
    gpu.set(118, 40, "┘") -- 5
    gpu.fill(118, 12, 1, 28, "│") -- 5
    gpu.set(118, 11, "┌") -- 5
    gpu.fill(119, 11, 42-traceEndOffset, 1, "─") -- 5
  elseif num == 6 then
    gpu.set(62, 8, "┌─┴─┐") -- 6
    gpu.set(64, 7, "┐") -- 6
    gpu.fill(45, 7, 19, 1, "─") -- 6
    gpu.set(44, 7, "┌") -- 6
    gpu.fill(44, 8, 1, 33, "│") -- 6
    gpu.set(44, 41, "└") -- 6
    gpu.fill(45, 41, 24, 1, "─") -- 6
    gpu.fill(70, 41, 20, 1, "─") -- 6
    gpu.fill(91, 41, 29, 1, "─") -- 6
    gpu.set(120, 41, "┘") -- 6
    gpu.fill(120, 13, 1, 28, "│") -- 6
    gpu.set(120, 12, "┌") -- 6
    gpu.fill(121, 12, 40-traceEndOffset, 1, "─") -- 6
  elseif num == 7 then
    gpu.set(76, 7, "⠏⠉⠉⠉⠉⠉⠉⠹") -- 7
    gpu.fill(79, 4, 1, 3, "⢸") -- 7
    gpu.fill(80, 4, 1, 3, "⡇") -- 7
    gpu.set(79, 3, "⢰⡶") -- 7
    gpu.fill(81, 3, 80-glw.width, 1, "⠶") -- 7
  elseif num == 8 then
    gpu.set(88, 38, "└─┬─┘") -- 8
    gpu.fill(90, 39, 1, 3, "│") -- 8
    gpu.set(90, 42, "└") -- 8
    gpu.fill(91, 42, 31, 1, "─") -- 8
    gpu.set(122, 42, "┘") -- 8
    gpu.fill(122, 14, 1, 28, "│") -- 8
    gpu.set(122, 13, "┌") -- 8
    gpu.fill(123, 13, 38-traceEndOffset, 1, "─") -- 8
  elseif num == 9 then
    gpu.set(67, 38, "└─┬─┘") -- 9
    gpu.fill(69, 39, 1, 4, "│") -- 9
    gpu.set(69, 43, "└") -- 9
    gpu.fill(70, 43, 54, 1, "─") -- 9
    gpu.set(124, 43, "┘") -- 9
    gpu.fill(124, 15, 1, 28, "│")
    gpu.set(124, 14, "┌") --9
    gpu.fill(125, 14, 36-traceEndOffset, 1, "─") -- 9
  end

  gpu.setForeground(0xFFFFFF)
end

function gateRingDisplay.reset()
  local self = gateRingDisplay
  self.engagedChevronCount = 0
  for i,v in ipairs(self.chevronStates) do self.chevronStates[i] = false end
  for i,v in ipairs(self.traceStates) do self.traceStates[i] = 0 end
  if self.isActive then
    for i,v in ipairs(self.chevronStates) do self.setChevron(i, v) end
    for i,v in ipairs(self.traceStates) do self.traces(i, v) end
  end
end

function gateRingDisplay.eventHorizon(isOpen)
  local self = gateRingDisplay
  if isOpen == nil then isOpen = self.eventHorizonState end
  if isOpen then
    self.eventHorizonState = true
  else
    self.eventHorizonState = false
  end
  if self.isActive then
    gpu.setForeground(self.ringColor)
    if isOpen then
      gpu.setBackground(self.horizonColor)
    else
      gpu.setBackground(0x000000)
    end
    for i,v in ipairs(self.topTbl) do
      gpu.set(66, 10+i, v)
    end
    for i,v in ipairs(self.midTbl) do
      gpu.set(57, 13+i, v)
    end
    for i,v in ipairs(self.botTbl) do
      gpu.set(66, 31+i, v)
    end
    for i,v in ipairs(self.chevronStates) do self.setChevron(i, v) end
  end
end

function gateRingDisplay.setChevron(num, isEngaged)
  local self = gateRingDisplay
  local stateColor = nil
  self.chevronStates[num] = isEngaged

  if num == 7 and HasRedstone then
    if self.chevronStates[7] and not UNGateResetting then
      redstone.setOutput(sides[RS_Settings.WormholeOpenSide], 15)
    -- else
      -- redstone.setOutput(sides[RS_Settings.WormholeOpenSide], 0)
    end
  end

  if not self.isActive then return end
  if isEngaged then
    stateColor = self.onColor
  else
    stateColor = self.offColor
  end
  gpu.setBackground(self.ringColor)
  gpu.setForeground(stateColor)
  if num == 1 then
    for i,v in ipairs(self.dotTbl) do -- 1
      gpu.set(93, 10+i, v)
    end
  elseif num == 2 then
    for i,v in ipairs(self.dotTbl) do -- 2
      gpu.set(103, 17+i, v)
    end
  elseif num == 3 then
    for i,v in ipairs(self.dotTbl) do -- 3
      gpu.set(101, 26+i, v)
    end
  elseif num == 4 then
    for i,v in ipairs(self.dotTbl) do -- 4
      gpu.set(54, 26+i, v)
    end
  elseif num == 5 then
    for i,v in ipairs(self.dotTbl) do -- 5
      gpu.set(52, 17+i, v)
    end
  elseif num == 6 then
    for i,v in ipairs(self.dotTbl) do -- 6
      gpu.set(62, 10+i, v)
    end
  elseif num == 7 then
    for i,v in ipairs(self.chevTbl) do -- 7
      gpu.set(77, 7+i, v)
    end
  elseif num == 8 then
    for i,v in ipairs(self.dot2Tbl) do -- 8
      if i ~= 3 then gpu.set(88, 33+i, v)
      else gpu.set(89, 33+i, v) end
    end
  elseif num == 9 then
    for i,v in ipairs(self.dot2Tbl) do -- 9
      if i ~= 3 then gpu.set(67, 33+i, v)
      else gpu.set(68, 33+i, v) end
    end
  end
  gpu.setBackground(0x000000)
  gpu.setForeground(0xFFFFFF)
end

function gateRingDisplay.dialedChevrons(count, hideImage)
  -- if IncomingWormhole then return end
  local self = gateRingDisplay
  if count == 0 then engagedChevronCount = 0 end
  if count <= self.engagedChevronCount then return end

  if HasRedstone and not UNGateResetting then
    redstone.setOutput(sides[RS_Settings.ChevronEngagedSide], 15)
    if DialingInterlocked then
      event.timer(0.25, function() redstone.setOutput(sides[RS_Settings.ChevronEngagedSide], 0) end)
    end
  end

  -- computer.beep() -- For debug
  local glyphName = DialedAddress[count]
  if glyphName == "" then
    if GateType == "MW" then
      glyphName = "Point of Origin"
    elseif GateType == "PG" then
      glyphName = "Subido"
    end
  end
  if editGateEntryMode and not addAddressMode then hideImage = true end
  if not hideImage then self.glyphImage(glyphName, true) end
  if count < 7 then
    self.setChevron(count, true)
    self.traces(count, 2)
  else
    if glyphName == "Point of Origin" or glyphName == "Glyph 17" or glyphName == "Subido" then
      self.setChevron(7, true)
      self.traces(7, 2)
    else
      self.setChevron(count+1, true)
      self.traces(count+1, 2)
    end
  end
  self.engagedChevronCount = self.engagedChevronCount + 1
end

function gateRingDisplay.UNreset()
  if UNGateResetting then
    return
  end
  UNGateResetting = true
  -- while true do
    -- os.sleep()
    -- local status = sg.getGateStatus()
    -- if status == "dialing" or status == "failing" then break end
  -- end
  local self = gateRingDisplay
  alert("STARGATE IS RESETTING", 1)
  local sequence = {[1]=7,[2]=1,[3]=2,[4]=3,[5]=8,[6]=9,[7]=4,[8]=5,[9]=6}
  local pos = 1
  while UNGateResetting do
    local status,_ = sg.getGateStatus()
    if pos > 9 then pos = 1 end
    self.setChevron(sequence[pos], true)
    os.sleep()
    self.setChevron(sequence[pos], false)
    pos = pos + 1
  end
  self.setChevron(sequence[pos], false)
  alert("STARGATE HAS RESET", 1)
end
-- End of Gate Ring Display --------------------------------------------------------

-- Event Section -------------------------------------------------------------------
local EventListeners = {
  stargate_spin_chevron_engaged = event.listen("stargate_spin_chevron_engaged", function(_, _, caller, num, lock, glyph)
    if not ComputerDialingWithDHD then
      if ComputerDialingInterlocked then
        if HasRedstone then
          redstone.setOutput(sides[RS_Settings.ChevronEngagedSide], 0)
          -- event.timer(0.5, function() redstone.setOutput(sides[RS_Settings.ChevronEngagedSide], 0) end)
        end

        if lock then
          alert("CHEVRON "..math.floor(num).." LOCKED", 1)
          if not AbortingDialing then sg.engageGate() end
          if not caller then os.sleep() end
        else
          if (num) < 7 then
          else
          end
          if not caller then os.sleep() end
          if not AbortingDialing then
            alert("CHEVRON "..math.floor(num).." ENGAGED", 0)
            dialNext(num)
          end
        end
      else
        -- os.sleep(0.1)
        local status, err = xpcall(glyphListWindow.showAddress, debug.traceback)
        if err ~= nil then ErrorMessage = err end
        HadNoError = status
        -- glyphListWindow.showAddress()
      end
    end
  end),

  stargate_dhd_chevron_engaged = event.listen("stargate_dhd_chevron_engaged", function(_, _, caller, num, lock, glyph)
    if not ComputerDialingWithDHD then
      local status, err = xpcall(glyphListWindow.showAddress, debug.traceback)
      if err ~= nil then ErrorMessage = err end
      HadNoError = status
    end
  end),

  stargate_incoming_wormhole = event.listen("stargate_incoming_wormhole", function(_, _, caller, dialedAddressSize)
    AddressBuffer = {}

    if IncomingWormhole == false then
      IncomingWormhole = true
      if ComputerDialingInterlocked then
        IncomingWormholeAbortDialing()
      end
      if IDC ~= nil and IrisSettings.AutoCloseIris == true and sg.getIrisState() == "OPENED" then
        sg.toggleIris()
      end
      if HasRedstone then
        redstone.setOutput(sides[RS_Settings.WormholeOpenSide], 15)
      end
      alert("INCOMING WORMHOLE", 2)
      if gateRingDisplay.isActive then
        gateRingDisplay.glyphImage()
        gateRingDisplay.reset()
        for i=1,dialedAddressSize do gateRingDisplay.chevronStates[i] = true end
        for i,v in ipairs(gateRingDisplay.chevronStates) do
          if i > 6 and i < dialedAddressSize then
            gateRingDisplay.setChevron(i+1, v)
          elseif i == dialedAddressSize then
           gateRingDisplay.setChevron(7, v)
          else
            gateRingDisplay.setChevron(i, v)
          end
          os.sleep(0.25)
        end
      end
      updateButtons()
      os.sleep(3)
      IncomingWormhole = false
    end
  end),

  stargate_open = event.listen("stargate_open", function(_, _, caller, isInitiating)
    local status, err = xpcall(function()
      WormholeConnected = true
      event.timer(0.05, function() gateRingDisplay.eventHorizon(true) end)
      -- gateRingDisplay.eventHorizon(true)
      if isInitiating then
        finishDialing()
        updateHistory()
      end
      if DialingInterlocked then DialingInterlocked = false end
      glyphListWindow.locked = false
      glyphListWindow.display()
      os.sleep(1)
    end, debug.traceback)
    if err ~= nil then ErrorMessage = err end
    HadNoError = status
  end),

  stargate_wormhole_stabilized = event.listen("stargate_wormhole_stabilized", function(_, _, caller, isInitiating)
    local status, err = xpcall(function()
      -- if dialerAdrEntryMode then
        -- event.timer(0.5, function()
          -- sg.disengageGate()
          -- dialerAdrEntryMode = false
        -- end)
      -- end
      if isInitiating and OutgoingIDC ~= nil then
        event.timer(1.5, function()
          alert("Sending IDC",1)
          os.sleep(0.5)
          sg.sendIrisCode(OutgoingIDC)
        end)
      end
    end, debug.traceback)
    if err ~= nil then ErrorMessage = err end
    HadNoError = status
  end),

  stargate_close = event.listen("stargate_close", function(_, _, caller, reason)
    local status, err = xpcall(function()
      if HasRedstone then
        redstone.setOutput(sides[RS_Settings.WormholeOpenSide], 0)
      end

      if not addAddressMode then
        -- if glyphListWindow.selectedGlyphs[#glyphListWindow.selectedGlyphs] < 1 then
          -- table.remove(glyphListWindow.selectedGlyphs) -- Redundant?
        -- end
        glyphListWindow.locked = false
        glyphListWindow.display()
      end
      gateRingDisplay.reset()
      os.sleep(1.5)
      alert("CONNECTION HAS CLOSED", 1)
      gateRingDisplay.eventHorizon(false)
    end, debug.traceback)
    if err ~= nil then ErrorMessage = err end
    HadNoError = status
  end),

  stargate_wormhole_closed_fully = event.listen("stargate_wormhole_closed_fully", function(_, _, caller, isInitiating)
    if sg.getIrisState() == "CLOSED" then
      sg.toggleIris()
    end
    OutgoingWormhole = false
    if GateType == "UN" then
      gateRingDisplay.UNreset()
    end
    updateButtons()
  end),

  stargate_failed = event.listen("stargate_failed", function(_, _, caller, reason)
    if reason == nil then return end
    if not AbortingDialing and not DHD_AdrEntryMode and not ComputerDialingWithDHD then
      if reason == "address_malformed" then
        alert("UNABLE TO ESTABLISH CONNECTION", 3)
      elseif reason == "not_enough_power" then
        alert("NOT ENOUGH POWER TO CONNECT", 3)
      elseif reason == "aborted" then
        alert("ABORTED BY HAND DIALER", 2)
      end
    end
    if GateType == "UN" and reason ~= "aborted" then
      gateRingDisplay.UNreset()
    end
    if ComputerDialingWithDHD then
      if reason == "address_malformed" then
        alert("UNABLE TO FINISH DIALING. MAKE SURE DHD HAS A DHD GLYPH CRYSTAL", 3)
      elseif reason == "dhd_not_connected" then
        alert("DHD IS NOT LINKED TO THE STARGATE",3)
      end
    end
    if not editGateEntryMode then gateRingDisplay.glyphImage() end
    if DHD_AdrEntryMode then gateRingDisplay.glyphImage() end
    gateRingDisplay.reset()
    if DialingInterlocked then DialingInterlocked = false end
    finishDialing()
    if not dialerAdrEntryMode and not DHD_AdrEntryMode then
      glyphListWindow.locked = false
      glyphListWindow.display()
    end
    if DHD_AdrEntryMode and not GoodAddress and #glyphListWindow.selectedGlyphs > 0 then
      if #glyphListWindow.selectedGlyphs >= 6 then
        local allGood = true
        for i,v in ipairs(glyphListWindow.selectedGlyphs) do
          if v < 1 then
            allGood = false
            break
          end
        end
        GoodAddress = allGood
      end
      if not GoodAddress then
        alert("Address is Invalid", 2)
      end
    end
    if AbortingDialing then AbortingDialing = false end
  end),

  modem_message = event.listen("modem_message", function(_, _, sender, port, _, msg)
    if port == ModemIDCPort and tonumber(msg) ~= nil then
      local code = tonumber(msg)
      if IDC == code then
        if sg.getIrisState() == "CLOSED" then
          sg.toggleIris()
          modem.send(sender, ModemIDCPort, "IDC Accepted!")
        else
          if IrisType == "SHIELD" then
            modem.send(sender, ModemIDCPort, "Shield is Off!")
          else
            modem.send(sender, ModemIDCPort, "Iris is Open!")
          end
        end
      elseif IDC ~= code and sg.getIrisState() == "CLOSED" then
        modem.send(sender, ModemIDCPort, "IDC is Incorrect!")
      end
    end
  end),

  received_code = event.listen("received_code", function(_, _, _, code)
    if IDC == code then
      if sg.getIrisState() == "CLOSED" then
        sg.toggleIris()
        sg.sendMessageToIncoming("IDC Accepted!")
      else
        if IrisType == "SHIELD" then
          sg.sendMessageToIncoming("Shield is Off!")
        else
          sg.sendMessageToIncoming("Iris is Open!")
        end
      end
    elseif IDC ~= code and sg.getIrisState() == "CLOSED" then
      sg.sendMessageToIncoming("IDC is Incorrect!")
    end
  end),

  code_respond = event.listen("code_respond", function(_, _, caller, msg)
    msg = string.sub(msg, 1, -3)
    alert(msg, 2)
    OutgoingIDC = nil
  end),

  key_down = event.listen("key_down", function(_, keyboardAddress, chr, code, playerName)
    User = playerName
    table.insert(keyCombo, code)
    if #keyCombo > 1 and (keyCombo[1] == 29 and keyCombo[2] == 16) and isAuthorized(User, AdminOnlySettings.Quit) then -- Ctrl+Q to Completely Exit
      if _G.agsKioskMode then _G.agsKioskMode = false end
      WasCanceled = true
      MainLoop = false
    end
    if code == 201 then GateEntriesWindow.increment(-1) end -- PgUp
    if code == 209 then GateEntriesWindow.increment(1) end  -- PgDn
  end),

  key_up = event.listen("key_up", function(_, keyboardAddress, chr, code, playerName)
    keyCombo = {}
    if code == 59 and not HelpButton.disabled then -- Toggles the instructions if F1 is pressed then released
      HelpWindow.toggle()
    end
    if code == 88 then toggleDebugMode() end -- F12 to toggle debug
    if code == 62 and not screen.isTouchModeInverted() then
      alert("TOUCH SCREEN MODE ACTIVATED", 1)
      screen.setTouchModeInverted(true)
    elseif code == 62 and screen.isTouchModeInverted() then
      alert("TOUCH SCREEN MODE DEACTIVATED", 1)
      screen.setTouchModeInverted(false)
    end
    if code == 65 then -- F7 Key
      DialingPaused = not DialingPaused
      if DialingPaused then
        alert("Dialing Has Been Paused", 2)
      elseif not DialingPaused then
        alert("Dialing Pause Has Been Released", 2)
      end
    end
    if code == 66 and component.isAvailable("dhd") then component.dhd.pressBRB() end -- F8 Key For Debug
    User = ""
  end),

  touch = event.listen("touch", function(_, screenAddress, x, y, button, playerName)
    local status, err = xpcall(function()
      User = playerName
      term.setCursor(0,0)
      if DebugMode then
        gpu.fill(150, 43, 10, 1, " ") -- For Debug
        gpu.set(150, 43, x..", "..y)  -- For Debug
      end
      if button == 0 then
        for i,v in ipairs(ActiveButtons) do
          if v:touch(x,y) then break end
        end
        glyphListWindow.touch(x, y)
        GateEntriesWindow.touch(x, y)
      end
      User = ""
    end, debug.traceback)
    if err ~= nil then ErrorMessage = err end
    HadNoError = status
  end),

  scroll = event.listen("scroll", function(_, screenAddress, x, y, direction, playerName)
      GateEntriesWindow.increment(direction*-1)
  end),

  -- component_unavailable = event.listen("component_unavailable", function(_, componentString)
    -- if componentString == "stargate" then
      -- alert(componentString, 3)
      -- error("Stargate Has Been Disconnected")
      -- ErrorMessage = "Stargate Has Been Disconnected"
      -- HadNoError = false
      -- while MainLoop do
        -- MainLoop = false
      -- end
    -- end
  -- end),

  interruptedEvent = event.listen("interrupted", function()
    if isAuthorized(User, AdminOnlySettings.Quit) then
      wasTerminated = true
      MainLoop = false
    end
  end),
}
-- End of Event Section ------------------------------------------------------------

-- Buttons -------------------------------------------------------------------------
buttons.dialButton = Button.new(41, 2, 0, 3, "  Dial  ", function()
  local gateEntry = nil
  if GateEntriesWindow.mode == "database" then
    gateEntry = gateEntries[GateEntriesWindow.selectedIndex]
  elseif GateEntriesWindow.mode == "history" then
    gateEntry = historyEntries[GateEntriesWindow.selectedIndex]
  end
  if AdminOnlySettings.AdminCanForceDialDHD and isAuthorized(User) and keyCombo[1] == 29 then
    ForceDialDHD = true
  end
  if not gateEntry.AdminOnly then
    dialAddress(gateEntry)
  elseif isAuthorized(User) then
    AdminDialed = (gateEntry.AdminOnly)
    dialAddress(gateEntry)
  end
end)
buttons.editButton = Button.new(64, 2, 0, 3, "Edit Entry", function()
  local gateEntry = gateEntries[GateEntriesWindow.selectedIndex]
  if gateEntry ~= nil then
    if isAuthorized(User, AdminOnlySettings.EditEntry) then
      if not gateEntry.AdminOnly then
        editGateEntry(GateEntriesWindow.selectedIndex)
      elseif isAuthorized(User) then
        editGateEntry(GateEntriesWindow.selectedIndex)
      end
    end
  else
    alert("SELECT A GATE ENTRY TO EDIT", 2)
  end
end)
buttons.renameButton = Button.new(47, 5, 23, 3, "", function()
  renameGateEntry(GateEntriesWindow.selectedIndex)
end, false)
buttons.changeEntryIDCButton = Button.new(77, 5, 11, 3, "", function()
  changeEntryIDC(GateEntriesWindow.selectedIndex)
end, false)
buttons.deleteButton = Button.new(41, 21, 0, 3, "Delete Entry", function() --56
  deleteGateEntry(0)
end)
buttons.deleteYesButton = Button.new(44, 23, 0, 3, " Yes ", function()
  deleteGateEntry(1)
end, false)
buttons.deleteNoButton = Button.new(44, 25, 0, 3, " No  ", function()
  deleteGateEntry(-1)
end, false)
buttons.addEntryButton = Button.new(52, 2, 0, 3, "Add Entry", function()
  if isAuthorized(User, AdminOnlySettings.AddEntry) then
    addNewGateEntry()
  end
end)
buttons.abortDialingButton = Button.new(41, 2, 0, 3, "Abort Dialing", function()
  abortDialing()
end)
buttons.glyphResetButton = Button.new(term.window.width-36, 16, 0, 0, "Reset", function()
  if GateStatusBool == nil and sg.dialedAddress ~= nil and sg.dialedAddress ~= "[]" then
    DHD_AdrEntryMode = true
    alert("CLEARING ENGAGED CHEVRONS", 2)
    if sg.abortDialing ~= nil and GateType ~= "UN" then
      directAbortDialing()
    else
      sg.engageGate()
    end
  end
  glyphListWindow.reset()
  for i,v in ipairs(gateRingDisplay.traceStates) do gateRingDisplay.traceStates[i] = 0 end
  if gateRingDisplay.isActive then
    for i,v in ipairs(gateRingDisplay.traceStates) do gateRingDisplay.traces(i, v) end
  end
end)
buttons.dhdEntryButton = Button.new(54, 7, 0, 0, "DHD", function()
  ChildThread.dhdAddressEntry = thread.create(dhdAddressEntry)
end)
buttons.dialerEntryButton = Button.new(54, 7, 0, 0, "Dialer", function()
  ChildThread.dialerAddressEntry = thread.create(dialerAddressEntry)
end)
buttons.manualEntryButton = Button.new(42, 7, 0, 0, "Manually", function()
  ChildThread.manualAddressEntry = thread.create(manualAddressEntry)
end)
buttons.addressEntry_MW_Button = Button.new(41, 9, 0, 0, "Milky Way", function()
  addressEntry("MW")
end, false)
buttons.addressEntry_UN_Button = Button.new(41, 10, 0, 0, "Universe", function()
  addressEntry("UN")
end, false)
buttons.addressEntry_PG_Button = Button.new(41, 11, 0, 0, "Pegasus", function()
  addressEntry("PG")
end, false)
buttons.cancelButton = Button.new(41, 2, 0, 0, "←─Back", function() -- Button.new(41, 2, 0, 0, "Cancel", function()
  glyphListWindow.locked = false
  WasCanceled = true
  manualAdrEntryMode = false
  glyphListWindow.initialize(GateType)
  if editGateEntryMode and addAddressMode then
    editGateEntry(GateEntriesWindow.selectedIndex)
  else
    editGateEntryMode = false
    mainInterface()
  end
  addAddressMode = false
  event.timer(0.5, function() WasCanceled = false end)
end)

QuitButton = Button.new(1, 41, 0, 3, "Quit", function()
  if isAuthorized(User, AdminOnlySettings.Quit) then
    if _G.agsKioskMode then _G.agsKioskMode = false end
    WasCanceled = true
    MainLoop = false
  end
end)
HelpButton = Button.new(8, 41, 0, 0, "Help", function()
  HelpWindow.toggle()
end)
CloseGateButton = Button.new(15, 41, 0, 3, "Close Gate", function()
  local s,f = sg.disengageGate()
  if f == "stargate_failure_wrong_end" then
    alert("CAN NOT CLOSE AN INCOMING CONNECTION", 2)
  elseif f == "stargate_failure_not_open" then
    alert("GATE IS NOT OPEN", 1)
  end
end)
IrisToggleButton = Button.new(28, 41, 0, 0, " ", function()
  if isAuthorized(User, AdminOnlySettings.ToggleIris) then
    sg.toggleIris()
  end
end)
-- IDCButton = Button.new(126, 41, 0, 0, "IDC", function()
  -- alert("Sending IDC: "..tostring(OutgoingIDC), 1)
  -- sg.sendIrisCode(OutgoingIDC)
-- end)


function updateButtons()
  if GateEntriesWindow.canDial[GateEntriesWindow.selectedIndex] == true and GateStatusString == "idle" then
    buttons.dialButton:disable(false)
    -- buttons.dialButton:display()
  else
    buttons.dialButton:disable(true)
    -- if sg.abortDialing ~= nil and DialingInterlocked then
      -- buttons.dialButton:hide()
      -- buttons.abortDialingButton:display()
    -- end
  end
  if GateEntriesWindow.mode == "database" then
    buttons.editButton:disable(false)
    buttons.addEntryButton:disable(false)
  elseif GateEntriesWindow.mode == "history" then
    buttons.editButton:disable(true)
    buttons.addEntryButton:disable(true)
  end
end
-- End of Buttons ------------------------------------------------------------------

-- Help Window ---------------------------------------------------------------------
HelpWindow = {visible=false}
function HelpWindow.toggle()
  local helpMessage = {
    "DIALING:",
    " To dial out select a Gate Entry from the list to the left, and click the",
    " 'Dial' button. You can also directly enter an address with the glyphs to",
    " the right, then click 'Origin' to begin dialing.",
    " ",
    "ADD ENTRY:",
    " To add a Gate to the 'Gate Entries' list click the 'Add Entry' button and",
    " follow the prompts.",
    " ",
    "EDIT ENTRY:",
    " To edit a Gate Entry, select it from the list and click the 'Edit Entry'",
    " button. On the 'Edit Entry' screen you can rename the entry, delete it, or",
    " change it's gate addresses.",
    " ",
    "KEY BINDS:",
    " F4: Toggles Touch Screen Mode",
    " F12: Toggles Debug Information",
    " Ctrl+Q: Closes the Dialer Program",
    " Ctrl+C: Forces the Dialer to Close",
    " ",
    "Dialer Version: "..Version
  }
  local self = HelpWindow
  self.xPos = 41
  self.yPos = 5
  self.width = 80
  self.height = 2 + #helpMessage
  if self.visible then
    self.visible = false
    mainInterface()
  elseif not self.visible then
    self.visible = true
    gateRingDisplay.isActive = false
    gpu.fill(self.xPos, self.yPos, self.width, self.height, " ")
    gpu.set(self.xPos, self.yPos,               "╔══════════════════════════════════════════════════════════════════════════════╗")
    gpu.set(self.xPos, self.yPos+self.height-1, "╚══════════════════════════════════════════════════════════════════════════════╝")
    gpu.fill(self.xPos, self.yPos+1, 1, self.height-2, "║")
    gpu.fill(self.xPos+self.width-1, self.yPos+1, 1, self.height-2, "║")
    for i,line in ipairs(helpMessage) do
      gpu.set(self.xPos+1, self.yPos+i, line)
    end
  end
end
-- End of Help Window --------------------------------------------------------------


-- Display Main Interface ----------------------------------------------------------
function mainInterface(shouldClear)
  if shouldClear == nil then
    clearDisplay()
    gateRingDisplay.draw()
  end
  if glyphListWindow.glyphType ~= GateType then glyphListWindow.initialize(GateType) end
  glyphListWindow.display()
  buttons.dialButton:display()
  buttons.editButton:display()
  buttons.addEntryButton:display()
  updateButtons()
  if HelpButton.disabled then HelpButton:disable(false) end
end
-- End of Display Main Interface ---------------------------------------------------


-- Initialization ------------------------------------------------------------------
local status, err = xpcall(function()
  localMWAddress = sg.stargateAddress.MILKYWAY
  localUNAddress = sg.stargateAddress.UNIVERSE
  localPGAddress = sg.stargateAddress.PEGASUS
  term.clear()
  initialLoadAddressFile()
  GateEntriesWindow.set()

  ChildThread.debugWindowThread:suspend()
  QuitButton:display()
  HelpWindow.visible = false
  HelpButton:display()
  glyphListWindow.initialize(GateType)
  gateRingDisplay.initialize()
  gateRingDisplay.draw()
  if sg.dialedAddress ~= nil and sg.dialedAddress ~= "[]" then
    DialedAddress = parseAddressString(sg.dialedAddress, GateType)
    glyphListWindow.showAddress()
    for i in ipairs(DialedAddress) do gateRingDisplay.dialedChevrons(i, true) end
  end
  mainInterface()
  displayInfoCenter()
  CloseGateButton:display()

  ChildThread.gateStatusThread = thread.create(function()
    while MainLoop and HadNoError do
      local status, err = xpcall(function()
        GateStatusString = nil
        GateStatusBool = nil
        pcall(function() GateStatusString, GateStatusBool = sg.getGateStatus() end)
        if GateStatusBool ~= nil and GateStatusBool == true then
          OutgoingWormhole = true
          if CloseGateButton.disabled then
            CloseGateButton:disable(false)
          end
        elseif not CloseGateButton.disabled then
          CloseGateButton:disable(true)
        end
        if HasRedstone then
          if GateStatusString ~= "idle" or ComputerDialingInterlocked then
            redstone.setOutput(sides[RS_Settings.GateIsActiveSide], 15)
          else
            redstone.setOutput(sides[RS_Settings.GateIsActiveSide], 0)
          end
        end
        if GateStatusString == "dialing" and not UNGateResetting and not ComputerDialingWithDHD then --and not DialingInterlocked then
          DialingInterlocked = true
          if sg.dialedAddress == "[]" then
            glyphListWindow.reset()
          end
        end
        if DialingInterlocked or ComputerDialingInterlocked then
          if not UNGateResetting and not IncomingWormhole then
            DialedAddress = parseAddressString(sg.dialedAddress, GateType)
            gateRingDisplay.dialedChevrons(#DialedAddress)
            -- glyphListWindow.insertAddress(DialedAddress)
            if buttons.glyphResetButton.visible then buttons.glyphResetButton:hide() end
            if not glyphListWindow.locked then glyphListWindow.locked = true end
            if GateStatusString == "dialing" and GateType == "UN" then
              -- glyphListWindow.insertAddress(DialedAddress)
              glyphListWindow.showAddress()
            end
          end
        end
        if GateStatusString == "idle" and not ComputerDialingInterlocked then
          if UNGateResetting then
            UNGateResetting = false
            if HasRedstone and WormholeConnected then
              redstone.setOutput(sides[RS_Settings.ExhaustVentSide], 15)
              event.timer(3.5, function()
                redstone.setOutput(sides[RS_Settings.ExhaustVentSide], 0)
              end)
            end
          end
          WormholeConnected = false
          if DialingInterlocked then
            DialingInterlocked = false
          end
          if glyphListWindow.locked and not editGateEntryMode then
            glyphListWindow.locked = false
            -- glyphListWindow.display()
          end
          if #glyphListWindow.selectedGlyphs > 0 and not buttons.glyphResetButton.visible then
            buttons.glyphResetButton:display()
          end
        end
        if GateStatusString == "dialing" and ComputerDialingInterlocked and not ComputerDialingWithDHD and not AbortingDialing then abortDialing() end -- If DHD is used while the computer is dialing, abort dialing.
      end, debug.traceback)
      if err ~= nil then ErrorMessage = err end
      HadNoError = status
      pcall(function() IrisType = sg.getIrisType() end)
      if IrisType == nil or IrisType == "NULL" then
        IrisToggleButton:hide()
      else
        local labelString = nil
        if IrisType == "SHIELD" then
          labelString = "Toggle Shield"
          IrisDurability = "∞ Shield ∞"
        else
          labelString = "Toggle Iris"
          IrisDurability = sg.getIrisDurability()
        end
        if not IrisToggleButton.visible or labelString ~= IrisToggleButton.label then
          IrisToggleButton:hide()
          IrisToggleButton.label = labelString
          IrisToggleButton.width = 1
          IrisToggleButton:display()
        end
      end
      freeMemoryPercent = tostring(math.floor((computer.freeMemory()/computer.totalMemory())*100)).."%"
      os.sleep()
    end
  end)

  runPlugin()

  -- Main Loop just to keep AGS alive. --
  while MainLoop and HadNoError do
    os.sleep(1)
  end

end, debug.traceback)
if err ~= nil then ErrorMessage = err end
HadNoError = status
-- Initialization End --------------------------------------------------------------


-- Closing Procedures --------------------------------------------------------------
DialingPaused = false
writeToDatabase()
while ChildThread.databaseWrite:status() ~= "dead" do end
term.clear()

-- Clean up buttons
for k,v in pairs(buttons) do
  k = nil
end
buttons = nil

-- Turn off all redstone
if HasRedstone then
  for i=0,5,1 do
    redstone.setOutput(i, 0)
  end
end

-- Clean up functions and variables
GateEntry = nil
HistoryEntry = nil
editGateEntry = nil

-- Clean up threads
for k,v in pairs(ChildThread) do
  if (wasTerminated or not HadNoError) and v:status() == "dead" then
    print(k..": dead already")
  else
    v:kill()
    if wasTerminated or not HadNoError then print(k..": "..v:status()) end -- For Debug
  end
end
event.cancel(ConfigPage.timer)

-- Clean up event listeners
for k,v in pairs(EventListeners) do
  if wasTerminated or not HadNoError then print("Canceling Event Listener: "..k) end -- For Debug
  event.cancel(v)
end
if wasTerminated or not HadNoError then
  print("Dialer Program Terminated")
else
  print("Dialer Program Closed")
end

-- Close Modem port if it was open
if HasModem and ModemIDCPort ~= nil then modem.close(ModemIDCPort) end

-- If error happen report the error
if ErrorMessage ~= nil then io.stderr:write(tostring(ErrorMessage)) end

-- If touch screen was on, turn it off
screen.setTouchModeInverted(false)

-- If cursor blink was off, turn it on
if not term.getCursorBlink() then term.setCursorBlink(true) end

-- Set global flag indicating AGS completed closing procedures
_G.agsProperlyClosed = true

-- End of Closing Procedures -------------------------------------------------------