wow-Heimdall/Modules/Config.lua

local addonname, shared = ...
---@cast shared HeimdallShared
---@cast addonname string

---@param str string
---@return table<string, boolean>
local function StringToMap(str, deliminer)
	if not str then return {} end
	local map = {}
	local parts = { strsplit(deliminer, str) }
	for _, line in ipairs(parts) do
		line = strtrim(line)
		if line ~= "" then map[line] = true end
	end
	return map
end

---@param str string
---@return string[]
local function StringToArray(str, deliminer)
	if not str then return {} end
	local ret = {}
	local array = { strsplit(deliminer, str) }
	for i, line in ipairs(array) do
		line = strtrim(line)
		if line ~= "" then ret[i] = line end
	end
	return ret
end

---@param map table<any, any>
---@param deliminer string
---@return string
local function MapKeyToString(map, deliminer)
	local str = ""
	for k, _ in pairs(map) do
		str = str .. k .. deliminer
	end
	return str
end
---@param map table<any, any>
---@param deliminer string
---@param terminator string
---@return string
local function MapToString(map, deliminer, terminator)
	local str = ""
	for k, v in pairs(map) do
		str = str .. k .. deliminer .. v .. terminator
	end
	return str
end
---@param str string
---@param deliminer string
---@param terminator string
---@return table<any, any>
local function MapFromString(str, deliminer, terminator)
	local map = {}
	local lines = shared.Split(str, terminator)
	for _, line in ipairs(lines) do
		local data = shared.Split(line, deliminer)
		if #data == 2 then
			map[data[1]] = data[2]
		else
			if Heimdall_Data.config.debug then print("Invalid data in map:", line) end
		end
	end
	return map
end
---@param map table<any, any>
---@param deliminer string
---@return string
local function MapValueToString(map, deliminer)
	local str = ""
	for _, v in pairs(map) do
		str = str .. tostring(v) .. deliminer
	end
	return str
end

---@class GridFrame:Frame
---@field name string
---@field columns number
---@field frame Frame
---@field cellWidth number
---@field cellHeight number
---@field columnHeights table<number, number>
GridFrame = {
	---@param name string
	---@param parent Frame
	---@param columns number
	---@param cellHeight number
	---@param size {w: number, h:number}?
	---@return GridFrame
	new = function(name, parent, columns, cellHeight, size)
		local self = setmetatable({}, {
			__index = GridFrame,
		})
		self.frame = CreateFrame("Frame", name, parent)
		size = size or {}
		if size.w then self.frame:SetWidth(size.w) end
		if size.h then self.frame:SetHeight(size.h) end
		self.allowOverflow = false
		self.frame:SetPoint("CENTER", parent, "CENTER")
		self.frame:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			tileSize = 64,
			tile = true,
		})
		self.frame:SetBackdropColor(0, 0, 0, 0.8)
		self.frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)

		self.columns = columns
		self.cellWidth = self.frame:GetWidth() / columns
		self.cellHeight = cellHeight
		self.columnHeights = {}
		for i = 1, columns do
			self.columnHeights[i] = 0
		end
		return self
	end,
	---@param self GridFrame
	---@param frame Frame
	---@param rowspan number
	---@param colspan number
	Add = function(self, frame, rowspan, colspan)
		colspan = math.min(colspan, self.columns)

		local bestColumn = nil
		local bestRow = math.huge

		for startColumn = 1, self.columns - colspan + 1 do
			local currentMaxY = 0
			for c = startColumn, startColumn + colspan - 1 do
				currentMaxY = math.max(currentMaxY, self.columnHeights[c])
			end
			if currentMaxY < bestRow then
				bestRow = currentMaxY
				bestColumn = startColumn
			end
		end

		if bestColumn then
			frame:SetParent(self.frame)
			frame.gridData = {
				row = bestRow,
				column = bestColumn,
				colspan = colspan,
				rowspan = rowspan,
				parent = self,
			}
			frame.SetPos = function(self)
				if not self.gridData then return end
				local parent = self.gridData.parent
				local x = (self.gridData.column - 1) * parent.cellWidth
				local y = -(self.gridData.row * parent.cellHeight)
				self:SetPoint("TOPLEFT", parent.frame, "TOPLEFT", x, y)
				self:SetWidth(parent.cellWidth * self.gridData.colspan)
				self:SetHeight(parent.cellHeight * self.gridData.rowspan)
			end
			frame.SetPos(frame)

			for c = bestColumn, bestColumn + colspan - 1 do
				self.columnHeights[c] = self.columnHeights[c] + rowspan
			end
		else
			print("No available space in the grid.")
		end
	end,
	Recalculate = function(self)
		local children = { self.frame:GetChildren() }
		for _, child in pairs(children) do
			if child.gridData then
				child:SetPos()
				--            else
				--                print("Child has no grid data", child)
			end
		end
	end,
	SetWidth = function(self, width)
		self.frame:SetWidth(width)
		self.cellWidth = width / self.columns
		self:Recalculate()
	end,
	SetHeight = function(self, height)
		self.frame:SetHeight(height)
		local tallestRow = 0
		for _, height in pairs(self.columnHeights) do
			tallestRow = math.max(tallestRow, height)
		end
		if tallestRow > 0 then self.cellHeight = height / tallestRow end
		self:Recalculate()
	end,
	SetPoint = function(self, point, relativeTo, relativePoint, offsetX, offsetY)
		self.frame:SetPoint(point, relativeTo, relativePoint, offsetX, offsetY)
		self:Recalculate()
	end,
	SetParent = function(self, parent)
		self.frame:SetParent(parent)
		self:Recalculate()
	end,
}

---@class StaticGridFrame
---@field name string
---@field rows number
---@field columns number
---@field frame Frame
---@field cellWidth number
---@field cellHeight number
---@field occupancy table<number, table<number, boolean>>
StaticGridFrame = {
	---@param name string
	---@param parent Frame
	---@param rows number
	---@param columns number
	---@param size {w: number, h:number}?
	---@return StaticGridFrame
	new = function(name, parent, rows, columns, size)
		local self = setmetatable({}, {
			__index = StaticGridFrame,
		})
		size = size or {}
		self.frame = CreateFrame("Frame", name, parent)
		self.frame:SetWidth(columns * 128)
		self.frame:SetHeight(rows * 128)
		self.frame:SetPoint("CENTER", UIParent, "CENTER")
		self.frame:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			tileSize = 64,
			tile = true,
		})
		self.frame:SetBackdropColor(0, 0, 0, 0.8)
		self.frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
		if size.w then self.frame:SetWidth(size.w) end
		if size.h then self.frame:SetHeight(size.h) end

		self.rows = rows
		self.columns = columns
		self.cellWidth = self.frame:GetWidth() / columns
		self.cellHeight = self.frame:GetHeight() / rows
		self.occupancy = {}
		for row = 1, rows do
			self.occupancy[row] = {}
			for column = 1, columns do
				self.occupancy[row][column] = false
			end
		end
		return self
	end,
	---@param self StaticGridFrame
	---@param frame Frame
	---@param rowspan number
	---@param colspan number
	Add = function(self, frame, rowspan, colspan)
		if rowspan > self.rows or colspan > self.columns then
			print("Rowspan or colspan exceeds grid dimensions.")
			return
		end

		for row = 1, self.rows do
			for col = 1, self.columns do
				if not self.occupancy[row][col] then
					local canPlace = true
					for r = row, row + rowspan - 1 do
						for c = col, col + colspan - 1 do
							-- Check if r or c is out of bounds or if the cell is occupied
							if r > self.rows or c > self.columns or self.occupancy[r][c] then
								canPlace = false
								break
							end
						end
						if not canPlace then break end
					end
					if canPlace then
						local x = (col - 1) * self.cellWidth
						local y = -(row - 1) * self.cellHeight
						frame.colspan = colspan
						frame.rowspan = rowspan
						frame:SetWidth(self.cellWidth * colspan)
						frame:SetHeight(self.cellHeight * rowspan)
						frame:SetPoint("TOPLEFT", self.frame, "TOPLEFT", x, y)
						frame:SetParent(self.frame)
						for r = row, row + rowspan - 1 do
							for c = col, col + colspan - 1 do
								self.occupancy[r][c] = true
							end
						end
						return
					end
				end
			end
		end
		print("No available space in the grid.")
	end,
	MakeMovable = function(self)
		self.frame:SetMovable(true)
		self.frame:EnableMouse(true)
		self.frame:RegisterForDrag("LeftButton")
		self.frame:SetScript("OnDragStart", function(self) self:StartMoving() end)
		self.frame:SetScript("OnDragStop", function(self) self:StopMovingOrSizing() end)
	end,
	Recalculate = function(self)
		for _, frame in pairs(self.frame:GetChildren()) do
			if frame.colspan then frame:SetWidth(self.cellWidth * frame.colspan) end
			if frame.rowspan then frame:SetHeight(self.cellHeight * frame.rowspan) end
		end
	end,
	SetWidth = function(self, width)
		self.frame:SetWidth(width)
		self.cellWidth = width / self.columns
		self:Recalculate()
	end,
	SetHeight = function(self, height)
		self.frame:SetHeight(height)
		self.cellHeight = height / self.rows
		self:Recalculate()
	end,
	SetPoint = function(self, point, relativeTo, relativePoint, offsetX, offsetY)
		self.frame:SetPoint(point, relativeTo, relativePoint, offsetX, offsetY)
		self:Recalculate()
	end,
	SetParent = function(self, parent)
		self.frame:SetParent(parent)
		self:Recalculate()
	end,
}
--/run HeimdallConfig:ClearAllPoints(); HeimdallConfig:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
local configFrame = StaticGridFrame.new("HeimdallConfig", UIParent, 120, 12, { w = 1024 + 1024, h = 1024 + 512 })
configFrame:MakeMovable()
configFrame.frame:SetScript("OnKeyUp", function(self, key)
	if key == "ESCAPE" then self:Hide() end
end)

local colorIndex = 1
local colors = {
	{ 1, 0, 0, 1 }, -- Red
	{ 0, 1, 0, 1 }, -- Green
	{ 0, 0, 1, 1 }, -- Blue
	{ 1, 1, 0, 1 }, -- Yellow
	{ 1, 0, 1, 1 }, -- Magenta
	{ 0, 1, 1, 1 }, -- Cyan
	{ 1, 1, 1, 1 }, -- White
	{ 1, 0.5, 0, 1 }, -- Orange
	{ 0.5, 0, 1, 1 }, -- Purple
	{ 1, 0.5, 0.5, 1 }, -- Pink
	{ 0.6, 0.4, 0.2, 1 }, -- Brown
	{ 0.5, 1, 0.5, 1 }, -- Light Green
	{ 1, 0.8, 0, 1 }, -- Dark Orange
	{ 0.8, 0, 1, 1 }, -- Dark Purple
	{ 0.13, 0.55, 0.13, 1 }, -- Olive Green
	{ 0, 0, 0.5, 1 }, -- Navy Blue
	{ 1, 0.5, 0.3, 1 }, -- Coral
	{ 0, 0.5, 0.5, 1 }, -- Teal
	{ 0.9, 0.7, 1, 1 }, -- Lavender
	{ 0.5, 0, 0, 1 }, -- Maroon
	{ 1, 0.84, 0, 1 }, -- Gold
	{ 0.44, 0.52, 0.57, 1 }, -- Slate Gray
	{ 1, 0.41, 0.71, 1 }, -- Hot Pink
	{ 0.91, 0.48, 0.2, 1 }, -- Burnt Sienna
}
local GetNextColor = function()
	local color = colors[colorIndex]
	colorIndex = colorIndex + 1
	if colorIndex > #colors then colorIndex = 1 end
	return unpack(color)
end

--HeimdallTestFrame = GridFrame.new("HeimdallPartyFrame", UIParent, 12, 20, { w = 1024, h = 1024 })
--for i = 1, 10 do
--    local frame = CreateFrame("Frame", "HeimdallPartyFrame" .. i, UIParent)
--    frame:SetBackdrop({
--        bgFile = "Interface/Tooltips/UI-Tooltip-Background",
--        tileSize = 64,
--        tile = true
--    })
--    frame:SetBackdropColor(unpack(colors[i % #colors + 1]))
--    frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
--    HeimdallTestFrame:Add(frame, 4, 2)
--end
--HeimdallTestFrame:SetHeight(128)
--HeimdallTestFrame:SetWidth(512)
--configFrame:Add(HeimdallTestFrame, 20, 12)

---@diagnostic disable-next-line: missing-fields
shared.Config = {}
function shared.Config.Init()
	configFrame.frame:SetScale(Heimdall_Data.config.scale)

	local buttonColors = {
		enabled = { 0, 1, 0, 1 },
		disabled = { 1, 0, 0, 1 },
	}
	local function CreateFancyText(name, parent, text, color)
		local r, g, b, a = unpack(color)
		local textFrame = CreateFrame("Frame", name .. "TextFrame", parent)
		local textElement = textFrame:CreateFontString(nil, "ARTWORK", "GameFontNormal")
		textElement:SetText(text)
		textElement:SetTextColor(r, g, b, a)
		textElement:SetPoint("CENTER", textFrame, "CENTER", 0, 0)
		textFrame:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
			tile = true,
			tileSize = 2,
			edgeSize = 12,
		})
		textFrame:SetBackdropColor(r, g, b, 0.3)
		textFrame:SetBackdropBorderColor(r, g, b, 0.5)
		return textFrame
	end
	---@param name string
	---@param parent Frame
	---@param onClick fun(): boolean
	local function CreateBasicButton(name, parent, text, onClick)
		local button = CreateFrame("Frame", name, parent)
		button:SetScript("OnMouseDown", function()
			local res = onClick()
			local color = res and buttonColors.enabled or buttonColors.disabled
			button:SetBackdropColor(unpack(color))
		end)
		button:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
			tile = true,
			tileSize = 2,
			edgeSize = 12,
			insets = {
				left = 2,
				right = 2,
				top = 2,
				bottom = 2,
			},
		})
		button.UpdateColor = function(self, state)
			local color = state and buttonColors.enabled or buttonColors.disabled
			self:SetBackdropColor(unpack(color))
		end
		--spotterEnableButton:SetChecked(Heimdall_Data.config.spotter.enabled)
		local spotterEnableButtonLabel = button:CreateFontString(nil, "OVERLAY", "GameFontNormal")
		spotterEnableButtonLabel:SetText(text or "")
		spotterEnableButtonLabel:SetAllPoints(button)
		return button
	end
	---@param name string
	---@param parent Frame
	---@param text string
	---@param onDone fun(editBox: Frame)
	local function CreateBasicSmallEditBox(name, parent, text, initialValue, onDone)
		local container = GridFrame.new(name, parent, 1, 1)
		local editBoxFrame = CreateFrame("Frame", name .. "EditBoxFrame", container.frame)
		local editBox = CreateFrame("EditBox", name .. "EditBox", editBoxFrame)
		local textFrame = CreateFrame("Frame", name .. "TextFrame", container.frame)
		local textElement = textFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
		textElement:SetText(text)

		editBox:SetAutoFocus(false)
		editBox:SetFontObject("GameFontNormal")
		editBox:SetText(Heimdall_Data.config.spotter.throttleTime)
		editBox:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
			tile = true,
			tileSize = 2,
			edgeSize = 12,
			insets = {
				left = 2,
				right = 2,
				top = 2,
				bottom = 2,
			},
		})
		editBox:SetBackdropColor(0.8, 0.8, 0.8, 1)
		editBox:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
		editBox:SetTextInsets(6, 6, 0, 0)
		editBox:SetScript("OnEnterPressed", function() editBox:ClearFocus() end)
		editBox:SetScript("OnEscapePressed", function() editBox:ClearFocus() end)
		editBox:SetScript("OnEditFocusLost", function() onDone(editBox) end)
		editBox:SetText(initialValue or "")
		container:Add(textFrame, 1, 1)
		container:Add(editBox, 2, 1)
		textElement:SetPoint("TOPLEFT", textFrame, "TOPLEFT", 2, -2)
		return container
	end
	---@param name string
	---@param parent Frame
	---@param text string
	---@param onDone fun(editBox: Frame)
	local function CreateBasicBigEditBox(name, parent, text, initialValue, onDone)
		local container = GridFrame.new(name, parent, 1, 100)
		local editBoxFrame = CreateFrame("Frame", name .. "EditBoxFrame", container.frame)
		local editBox = CreateFrame("EditBox", name .. "EditBox", editBoxFrame)
		local textFrame = CreateFrame("Frame", name .. "TextFrame", container.frame)
		local textElement = textFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
		textElement:SetText(text)

		editBoxFrame:SetBackdrop({
			bgFile = "Interface/Tooltips/UI-Tooltip-Background",
			edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
			tile = true,
			tileSize = 2,
			edgeSize = 12,
			insets = {
				left = 2,
				right = 2,
				top = 2,
				bottom = 2,
			},
		})
		editBoxFrame:SetBackdropColor(0.8, 0.8, 0.8, 1)
		editBoxFrame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)

		editBox:SetAllPoints(editBoxFrame)
		editBox:SetAutoFocus(false)
		editBox:SetFontObject("GameFontNormal")
		editBox:SetText(initialValue or "")
		editBox:SetTextInsets(6, 6, 6, 6)
		editBox:SetMultiLine(true)
		editBox:SetSize(280, 100)
		editBox:SetMaxLetters(100000)
		editBox:SetScript("OnEscapePressed", function() editBox:ClearFocus() end)
		editBox:SetScript("OnEditFocusLost", function() onDone(editBox) end)
		container:Add(textFrame, 1, 1)
		container:Add(editBoxFrame, 7, 1)
		textElement:SetPoint("TOPLEFT", textFrame, "TOPLEFT", 2, -2)
		return container
	end

	local scale = CreateBasicSmallEditBox(
		"HeimdallConfigScale",
		configFrame.frame,
		"Scale",
		Heimdall_Data.config.scale,
		function(self)
			local text = self:GetText()
			if string.match(text, "^%d+%.*%d*$") then
				Heimdall_Data.config.scale = tonumber(text)
				configFrame.frame:SetScale(Heimdall_Data.config.scale)
			else
				print(string.format("Invalid scale: %s, please use numbers", text))
				self:SetText(Heimdall_Data.config.scale)
			end
		end
	)
	configFrame:Add(scale, 2, 2)
	local title = configFrame.frame:CreateFontString(nil, "ARTWORK", "GameFontNormal")
	title:SetText(string.format("%s - v%s", shared._L("heimdallConfig", Heimdall_Data.config.locale), shared.VERSION))
	configFrame:Add(title, 2, 7)

	local debug = CreateBasicButton(
		"HeimdallConfigDebug",
		configFrame.frame,
		shared._L("debug", Heimdall_Data.config.locale),
		function()
			Heimdall_Data.config.debug = not Heimdall_Data.config.debug
			return Heimdall_Data.config.debug
		end
	)
	debug:UpdateColor(Heimdall_Data.config.debug)
	configFrame:Add(debug, 2, 1)

	local russian = nil
	local english = CreateBasicButton(
		"HeimdallConfigEnglish",
		configFrame.frame,
		shared._L("english", Heimdall_Data.config.locale),
		function()
			Heimdall_Data.config.locale = "en"
			russian:UpdateColor(false)
			return Heimdall_Data.config.locale == "en"
		end
	)
	english:UpdateColor(Heimdall_Data.config.locale == "en")
	russian = CreateBasicButton(
		"HeimdallConfigRussian",
		configFrame.frame,
		shared._L("russian", Heimdall_Data.config.locale),
		function()
			Heimdall_Data.config.locale = "ru"
			english:UpdateColor(false)
			return Heimdall_Data.config.locale == "ru"
		end
	)
	russian:UpdateColor(Heimdall_Data.config.locale == "ru")
	configFrame:Add(english, 2, 1)
	configFrame:Add(russian, 2, 1)

	-- Spotter
	do
		local r, g, b, a = GetNextColor()
		local spotterConfigFrame = GridFrame.new("HeimdallSpotterConfig", UIParent, 12, 20)
		spotterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(spotterConfigFrame, 9, 3)

		local title = CreateFancyText(
			"HeimdallSpotterConfigTitle",
			spotterConfigFrame.frame,
			shared._L("spotter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		spotterConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallSpotterConfigDebugButton",
			spotterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.debug = not Heimdall_Data.config.spotter.debug
				return Heimdall_Data.config.spotter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.spotter.debug)
		spotterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallSpotterConfigEnableButton",
			spotterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.enabled = not Heimdall_Data.config.spotter.enabled
				return Heimdall_Data.config.spotter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.spotter.enabled)
		spotterConfigFrame:Add(enableButton, 1, 6)

		local everyoneButton = CreateBasicButton(
			"HeimdallSpotterConfigEveryoneButton",
			spotterConfigFrame.frame,
			shared._L("everyone", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.everyone = not Heimdall_Data.config.spotter.everyone
				return Heimdall_Data.config.spotter.everyone
			end
		)
		everyoneButton:UpdateColor(Heimdall_Data.config.spotter.everyone)
		spotterConfigFrame:Add(everyoneButton, 1, 6)

		local hostileButton = CreateBasicButton(
			"HeimdallSpotterConfigHostileButton",
			spotterConfigFrame.frame,
			shared._L("hostile", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.hostile = not Heimdall_Data.config.spotter.hostile
				return Heimdall_Data.config.spotter.hostile
			end
		)
		hostileButton:UpdateColor(Heimdall_Data.config.spotter.hostile)
		spotterConfigFrame:Add(hostileButton, 1, 4)

		local allianceButton = CreateBasicButton(
			"HeimdallSpotterConfigAllianceButton",
			spotterConfigFrame.frame,
			shared._L("alliance", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.alliance = not Heimdall_Data.config.spotter.alliance
				return Heimdall_Data.config.spotter.alliance
			end
		)
		allianceButton:UpdateColor(Heimdall_Data.config.spotter.alliance)
		spotterConfigFrame:Add(allianceButton, 1, 4)

		local stinkyButton = CreateBasicButton(
			"HeimdallSpotterConfigStinkyButton",
			spotterConfigFrame.frame,
			shared._L("stinky", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.spotter.stinky = not Heimdall_Data.config.spotter.stinky
				return Heimdall_Data.config.spotter.stinky
			end
		)
		stinkyButton:UpdateColor(Heimdall_Data.config.spotter.stinky)
		spotterConfigFrame:Add(stinkyButton, 1, 4)

		local channels = CreateBasicSmallEditBox(
			"HeimdallSpotterConfigChannels",
			spotterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.spotter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.spotter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.spotter.channels)
			end
		)
		spotterConfigFrame:Add(channels, 2, 4)

		local zoneOverride = CreateBasicSmallEditBox(
			"HeimdallSpotterConfigZoneOverride",
			spotterConfigFrame.frame,
			shared._L("zoneOverride", Heimdall_Data.config.locale),
			Heimdall_Data.config.spotter.zoneOverride,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.spotter.zoneOverride = text
					print("Zone override set to", tostring(text))
				else
					print("Invalid zone override", tostring(text))
					self:SetText(Heimdall_Data.config.spotter.zoneOverride)
				end
			end
		)
		spotterConfigFrame:Add(zoneOverride, 2, 4)

		local throttleTime = CreateBasicSmallEditBox(
			"HeimdallSpotterConfigThrottleTime",
			spotterConfigFrame.frame,
			shared._L("throttle", Heimdall_Data.config.locale),
			Heimdall_Data.config.spotter.throttleTime,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.spotter.throttleTime = tonumber(text)
				else
					print("Invalid throttle time", tostring(text))
					self:SetText(Heimdall_Data.config.spotter.throttleTime)
				end
			end
		)
		spotterConfigFrame:Add(throttleTime, 2, 4)
	end

	-- Whoer
	do
		local r, g, b, a = GetNextColor()
		local whoerConfigFrame = GridFrame.new("HeimdallWhoerConfig", UIParent, 12, 20)
		whoerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(whoerConfigFrame, 30, 6)

		local title = CreateFancyText(
			"HeimdallWhoerConfigTitle",
			whoerConfigFrame.frame,
			shared._L("whoer", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		whoerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallWhoerConfigDebugButton",
			whoerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.who.debug = not Heimdall_Data.config.who.debug
				return Heimdall_Data.config.who.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.who.debug)
		whoerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallWhoerConfigEnableButton",
			whoerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.who.enabled = not Heimdall_Data.config.who.enabled
				return Heimdall_Data.config.who.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.who.enabled)
		whoerConfigFrame:Add(enableButton, 2, 3)

		local doWhisperButton = CreateBasicButton(
			"HeimdallWhoerConfigDoWhisperButton",
			whoerConfigFrame.frame,
			shared._L("doWhisper", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.who.doWhisper = not Heimdall_Data.config.who.doWhisper
				return Heimdall_Data.config.who.doWhisper
			end
		)
		doWhisperButton:UpdateColor(Heimdall_Data.config.who.doWhisper)
		whoerConfigFrame:Add(doWhisperButton, 2, 3)

		local channels = CreateBasicSmallEditBox(
			"HeimdallWhoerConfigChannels",
			whoerConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.who.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.who.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.who.channels)
			end
		)
		whoerConfigFrame:Add(channels, 2, 3)

		local ttl = CreateBasicSmallEditBox(
			"HeimdallWhoerConfigTTL",
			whoerConfigFrame.frame,
			shared._L("ttl", Heimdall_Data.config.locale),
			Heimdall_Data.config.who.ttl,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.who.ttl = tonumber(text)
					print("TTL set to", tostring(text))
				else
					print("Invalid TTL", tostring(text))
					self:SetText(Heimdall_Data.config.who.ttl)
				end
			end
		)
		whoerConfigFrame:Add(ttl, 2, 3)

		local ignored = CreateBasicBigEditBox(
			"HeimdallWhoerConfigIgnored",
			whoerConfigFrame.frame,
			shared._L("ignored", Heimdall_Data.config.locale),
			MapKeyToString(Heimdall_Data.config.who.ignored or {}, ","),
			function(self)
				local ignored = StringToMap(self:GetText(), ",")
				Heimdall_Data.config.who.ignored = ignored
			end
		)
		whoerConfigFrame:Add(ignored, 4, 6)

		local zoneNotifyFor = CreateBasicBigEditBox(
			"HeimdallWhoerConfigZoneNotifyFor",
			whoerConfigFrame.frame,
			shared._L("zoneNotifyFor", Heimdall_Data.config.locale),
			MapKeyToString(Heimdall_Data.config.who.zoneNotifyFor or {}, "\n"),
			function(self)
				local zoneNotifyFor = StringToMap(self:GetText(), "\n")
				Heimdall_Data.config.who.zoneNotifyFor = zoneNotifyFor
			end
		)
		whoerConfigFrame:Add(zoneNotifyFor, 4, 6)

		local whoQueries = CreateBasicBigEditBox(
			"HeimdallWhoerConfigQueries",
			whoerConfigFrame.frame,
			shared._L("queries", Heimdall_Data.config.locale),
			shared.WhoQueryService.WhoQueriesToString(shared.WhoQueryService.queries or {}),
			function(self)
				Heimdall_Data.config.who.queries = self:GetText()
				shared.WhoQueryService.queries = shared.WhoQueryService.WhoQueriesFromString(self:GetText())
			end
		)
		whoerConfigFrame:Add(whoQueries, 12, 12)
	end

	-- Messenger
	do
		local r, g, b, a = GetNextColor()
		local messengerConfigFrame = GridFrame.new("HeimdallMessengerConfig", UIParent, 12, 20)
		messengerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(messengerConfigFrame, 6, 3)

		local title = CreateFancyText(
			"HeimdallMessengerConfigTitle",
			messengerConfigFrame.frame,
			shared._L("messenger", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		messengerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallMessengerConfigDebugButton",
			messengerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.messenger.debug = not Heimdall_Data.config.messenger.debug
				return Heimdall_Data.config.messenger.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.messenger.debug)
		messengerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallMessengerConfigEnableButton",
			messengerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.messenger.enabled = not Heimdall_Data.config.messenger.enabled
				return Heimdall_Data.config.messenger.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.messenger.enabled)
		messengerConfigFrame:Add(enableButton, 2, 3)

		local interval = CreateBasicSmallEditBox(
			"HeimdallMessengerConfigInterval",
			messengerConfigFrame.frame,
			shared._L("interval", Heimdall_Data.config.locale),
			Heimdall_Data.config.messenger.interval,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.messenger.interval = tonumber(text)
					print("Interval set to", tostring(text))
				else
					print("Invalid interval", tostring(text))
					self:SetText(Heimdall_Data.config.messenger.interval)
				end
			end
		)
		messengerConfigFrame:Add(interval, 2, 3)
	end

	-- Death Reporter
	do
		local r, g, b, a = GetNextColor()
		local deathReporterConfigFrame = GridFrame.new("HeimdallDeathReporterConfig", UIParent, 12, 20)
		deathReporterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(deathReporterConfigFrame, 10, 3)

		local title = CreateFancyText(
			"HeimdallDeathReporterConfigTitle",
			deathReporterConfigFrame.frame,
			shared._L("deathReporter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		deathReporterConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallDeathReporterConfigDebugButton",
			deathReporterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.deathReporter.debug = not Heimdall_Data.config.deathReporter.debug
				return Heimdall_Data.config.deathReporter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.deathReporter.debug)
		deathReporterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallDeathReporterConfigEnableButton",
			deathReporterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.deathReporter.enabled = not Heimdall_Data.config.deathReporter.enabled
				return Heimdall_Data.config.deathReporter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.deathReporter.enabled)
		deathReporterConfigFrame:Add(enableButton, 1, 6)

		local doWhisperButton = CreateBasicButton(
			"HeimdallDeathReporterConfigDoWhisperButton",
			deathReporterConfigFrame.frame,
			shared._L("doWhisper", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.deathReporter.doWhisper = not Heimdall_Data.config.deathReporter.doWhisper
				return Heimdall_Data.config.deathReporter.doWhisper
			end
		)
		doWhisperButton:UpdateColor(Heimdall_Data.config.deathReporter.doWhisper)
		deathReporterConfigFrame:Add(doWhisperButton, 1, 6)

		local throttleTime = CreateBasicSmallEditBox(
			"HeimdallDeathReporterConfigThrottleTime",
			deathReporterConfigFrame.frame,
			shared._L("throttle", Heimdall_Data.config.locale),
			Heimdall_Data.config.deathReporter.throttle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.deathReporter.throttle = tonumber(text)
					print("Throttle time set to", tostring(text))
				else
					print("Invalid throttle time", tostring(text))
					self:SetText(Heimdall_Data.config.deathReporter.throttle)
				end
			end
		)
		deathReporterConfigFrame:Add(throttleTime, 2, 6)

		local duelThrottle = CreateBasicSmallEditBox(
			"HeimdallDeathReporterConfigDuelThrottle",
			deathReporterConfigFrame.frame,
			shared._L("duelThrottle", Heimdall_Data.config.locale),
			Heimdall_Data.config.deathReporter.duelThrottle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.deathReporter.duelThrottle = tonumber(text)
					print("Duel throttle set to", tostring(text))
				else
					print("Invalid duel throttle", tostring(text))
					self:SetText(Heimdall_Data.config.deathReporter.duelThrottle)
				end
			end
		)
		deathReporterConfigFrame:Add(duelThrottle, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallDeathReporterConfigChannels",
			deathReporterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.deathReporter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.deathReporter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.deathReporter.channels)
			end
		)
		deathReporterConfigFrame:Add(channels, 2, 6)

		local zoneOverride = CreateBasicSmallEditBox(
			"HeimdallDeathReporterConfigZoneOverride",
			deathReporterConfigFrame.frame,
			shared._L("zoneOverride", Heimdall_Data.config.locale),
			Heimdall_Data.config.deathReporter.zoneOverride,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.deathReporter.zoneOverride = text
					print("Zone override set to", tostring(text))
				else
					print("Invalid zone override", tostring(text))
					self:SetText(Heimdall_Data.config.deathReporter.zoneOverride)
				end
			end
		)
		deathReporterConfigFrame:Add(zoneOverride, 2, 6)
	end

	-- Inviter
	do
		local r, g, b, a = GetNextColor()
		local inviterConfigFrame = GridFrame.new("HeimdallInviterConfig", UIParent, 12, 20)
		inviterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(inviterConfigFrame, 13, 3)

		local title = CreateFancyText(
			"HeimdallInviterConfigTitle",
			inviterConfigFrame.frame,
			shared._L("inviter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		inviterConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallInviterConfigDebugButton",
			inviterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.inviter.debug = not Heimdall_Data.config.inviter.debug
				return Heimdall_Data.config.inviter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.inviter.debug)
		inviterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallInviterConfigEnableButton",
			inviterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.inviter.enabled = not Heimdall_Data.config.inviter.enabled
				return Heimdall_Data.config.inviter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.inviter.enabled)
		inviterConfigFrame:Add(enableButton, 1, 3)

		local allAssistButton = CreateBasicButton(
			"HeimdallInviterConfigAllAssistButton",
			inviterConfigFrame.frame,
			shared._L("allAssist", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.inviter.allAssist = not Heimdall_Data.config.inviter.allAssist
				return Heimdall_Data.config.inviter.allAssist
			end
		)
		allAssistButton:UpdateColor(Heimdall_Data.config.inviter.allAssist)
		inviterConfigFrame:Add(allAssistButton, 1, 3)

		local agentsAssist = CreateBasicButton(
			"HeimdallInviterConfigAgentsAssistButton",
			inviterConfigFrame.frame,
			shared._L("agentsAssist", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.inviter.agentsAssist = not Heimdall_Data.config.inviter.agentsAssist
				return Heimdall_Data.config.inviter.agentsAssist
			end
		)
		agentsAssist:UpdateColor(Heimdall_Data.config.inviter.agentsAssist)
		inviterConfigFrame:Add(agentsAssist, 1, 3)

		local kickOffline = CreateBasicButton(
			"HeimdallInviterConfigKickOfflineButton",
			inviterConfigFrame.frame,
			shared._L("kickOffline", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.inviter.kickOffline = not Heimdall_Data.config.inviter.kickOffline
				return Heimdall_Data.config.inviter.kickOffline
			end
		)
		kickOffline:UpdateColor(Heimdall_Data.config.inviter.kickOffline)
		inviterConfigFrame:Add(kickOffline, 1, 3)

		local throttle = CreateBasicSmallEditBox(
			"HeimdallInviterConfigThrottle",
			inviterConfigFrame.frame,
			shared._L("throttle", Heimdall_Data.config.locale),
			Heimdall_Data.config.inviter.throttle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.inviter.throttle = tonumber(text)
					print("Throttle time set to", tostring(text))
				else
					print("Invalid throttle time", tostring(text))
					self:SetText(Heimdall_Data.config.inviter.throttle)
				end
			end
		)
		inviterConfigFrame:Add(throttle, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallInviterConfigChannels",
			inviterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.inviter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.inviter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.inviter.channels)
			end
		)
		inviterConfigFrame:Add(channels, 2, 6)

		local keyword = CreateBasicSmallEditBox(
			"HeimdallInviterConfigKeywords",
			inviterConfigFrame.frame,
			shared._L("keyword", Heimdall_Data.config.locale),
			Heimdall_Data.config.inviter.keyword,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.inviter.keyword = text
					print("Keyword set to", tostring(text))
				else
					print("Invalid keyword", tostring(text))
					self:SetText(Heimdall_Data.config.inviter.keyword)
				end
			end
		)
		inviterConfigFrame:Add(keyword, 2, 6)

		local cleanupInterval = CreateBasicSmallEditBox(
			"HeimdallInviterConfigCleanupInterval",
			inviterConfigFrame.frame,
			shared._L("cleanupInterval", Heimdall_Data.config.locale),
			Heimdall_Data.config.inviter.cleanupInterval,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.inviter.cleanupInterval = tonumber(text)
					print("Cleanup interval set to", tostring(text))
				else
					print("Invalid cleanup interval", tostring(text))
					self:SetText(Heimdall_Data.config.inviter.cleanupInterval)
				end
			end
		)
		inviterConfigFrame:Add(cleanupInterval, 2, 6)

		local afkThreshold = CreateBasicSmallEditBox(
			"HeimdallInviterConfigAfkThreshold",
			inviterConfigFrame.frame,
			shared._L("afkThreshold", Heimdall_Data.config.locale),
			Heimdall_Data.config.inviter.afkThreshold,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.inviter.afkThreshold = tonumber(text)
					print("Afk threshold set to", tostring(text))
				end
			end
		)
		inviterConfigFrame:Add(afkThreshold, 2, 6)
	end

	-- Dueler
	do
		local r, g, b, a = GetNextColor()
		local duelerConfigFrame = GridFrame.new("HeimdallDuelerConfig", UIParent, 12, 20)
		duelerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(duelerConfigFrame, 4, 3)

		local title = CreateFancyText(
			"HeimdallDuelerConfigTitle",
			duelerConfigFrame.frame,
			shared._L("dueler", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		duelerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallDuelerConfigDebugButton",
			duelerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.dueler.debug = not Heimdall_Data.config.dueler.debug
				return Heimdall_Data.config.dueler.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.dueler.debug)
		duelerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallInviterConfigEnableButton",
			duelerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.dueler.enabled = not Heimdall_Data.config.dueler.enabled
				return Heimdall_Data.config.dueler.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.dueler.enabled)
		duelerConfigFrame:Add(enableButton, 1, 6)

		local declineOther = CreateBasicButton(
			"HeimdallDuelerConfigDeclineOtherButton",
			duelerConfigFrame.frame,
			shared._L("declineOther", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.dueler.declineOther = not Heimdall_Data.config.dueler.declineOther
				return Heimdall_Data.config.dueler.declineOther
			end
		)
		declineOther:UpdateColor(Heimdall_Data.config.dueler.declineOther)
		duelerConfigFrame:Add(declineOther, 1, 6)
	end

	-- Agent Tracker
	do
		local r, g, b, a = GetNextColor()
		local agentTrackerConfigFrame = GridFrame.new("HeimdallAgentTrackerConfig", UIParent, 12, 20)
		agentTrackerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(agentTrackerConfigFrame, 5, 3)

		local title = CreateFancyText(
			"HeimdallAgentTrackerConfigTitle",
			agentTrackerConfigFrame.frame,
			shared._L("agentTracker", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		agentTrackerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallAgentTrackerConfigDebugButton",
			agentTrackerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.agentTracker.debug = not Heimdall_Data.config.agentTracker.debug
				return Heimdall_Data.config.agentTracker.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.agentTracker.debug)
		agentTrackerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallAgentTrackerConfigEnableButton",
			agentTrackerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.agentTracker.enabled = not Heimdall_Data.config.agentTracker.enabled
				return Heimdall_Data.config.agentTracker.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.agentTracker.enabled)
		agentTrackerConfigFrame:Add(enableButton, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallAgentTrackerConfigChannels",
			agentTrackerConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.agentTracker.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.agentTracker.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.agentTracker.channels)
			end
		)
		agentTrackerConfigFrame:Add(channels, 2, 6)
	end

	-- Stinky Tracker
	do
		local r, g, b, a = GetNextColor()
		local stinkyTrackerConfigFrame = GridFrame.new("HeimdallStinkyTrackerConfig", UIParent, 12, 20)
		stinkyTrackerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(stinkyTrackerConfigFrame, 5, 3)

		local title = CreateFancyText(
			"HeimdallStinkyTrackerConfigTitle",
			stinkyTrackerConfigFrame.frame,
			shared._L("stinkyTracker", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		stinkyTrackerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallStinkyTrackerConfigDebugButton",
			stinkyTrackerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.stinkyTracker.debug = not Heimdall_Data.config.stinkyTracker.debug
				return Heimdall_Data.config.stinkyTracker.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.stinkyTracker.debug)
		stinkyTrackerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallStinkyTrackerConfigEnableButton",
			stinkyTrackerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.stinkyTracker.enabled = not Heimdall_Data.config.stinkyTracker.enabled
				return Heimdall_Data.config.stinkyTracker.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.stinkyTracker.enabled)
		stinkyTrackerConfigFrame:Add(enableButton, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallStinkyTrackerConfigChannels",
			stinkyTrackerConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.stinkyTracker.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.stinkyTracker.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.stinkyTracker.channels)
			end
		)
		stinkyTrackerConfigFrame:Add(channels, 2, 6)
	end

	-- Emoter
	do
		local r, g, b, a = GetNextColor()
		local emoterConfigFrame = GridFrame.new("HeimdallEmoterConfig", UIParent, 12, 20)
		emoterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(emoterConfigFrame, 7, 3)

		local title = CreateFancyText(
			"HeimdallEmoterConfigTitle",
			emoterConfigFrame.frame,
			shared._L("emoter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		emoterConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallEmoterConfigDebugButton",
			emoterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.emoter.debug = not Heimdall_Data.config.emoter.debug
				return Heimdall_Data.config.emoter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.emoter.debug)
		emoterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallEmoterConfigEnableButton",
			emoterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.emoter.enabled = not Heimdall_Data.config.emoter.enabled
				return Heimdall_Data.config.emoter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.emoter.enabled)
		emoterConfigFrame:Add(enableButton, 1, 12)

		local channels = CreateBasicSmallEditBox(
			"HeimdallEmoterConfigChannels",
			emoterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.emoter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.emoter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.emoter.channels)
			end
		)
		emoterConfigFrame:Add(channels, 2, 6)

		local prefix = CreateBasicSmallEditBox(
			"HeimdallEmoterConfigPrefix",
			emoterConfigFrame.frame,
			shared._L("prefix", Heimdall_Data.config.locale),
			Heimdall_Data.config.emoter.prefix,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.emoter.prefix = text
					print("Prefix set to", tostring(text))
				else
					print("Invalid prefix", tostring(text))
					self:SetText(Heimdall_Data.config.emoter.prefix)
				end
			end
		)
		emoterConfigFrame:Add(prefix, 2, 6)
	end

	-- Echoer
	do
		local r, g, b, a = GetNextColor()
		local echoerConfigFrame = GridFrame.new("HeimdallEchoerConfig", UIParent, 12, 20)
		echoerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(echoerConfigFrame, 7, 3)

		local title = CreateFancyText(
			"HeimdallEchoerConfigTitle",
			echoerConfigFrame.frame,
			shared._L("echoer", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		echoerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallEchoerConfigDebugButton",
			echoerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.echoer.debug = not Heimdall_Data.config.echoer.debug
				return Heimdall_Data.config.echoer.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.echoer.debug)
		echoerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallEmoterConfigEnableButton",
			echoerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.echoer.enabled = not Heimdall_Data.config.echoer.enabled
				return Heimdall_Data.config.echoer.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.echoer.enabled)
		echoerConfigFrame:Add(enableButton, 1, 12)

		local channels = CreateBasicSmallEditBox(
			"HeimdallEmoterConfigChannels",
			echoerConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.echoer.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.echoer.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.echoer.channels)
			end
		)
		echoerConfigFrame:Add(channels, 2, 6)

		local prefix = CreateBasicSmallEditBox(
			"HeimdallEmoterConfigPrefix",
			echoerConfigFrame.frame,
			shared._L("prefix", Heimdall_Data.config.locale),
			Heimdall_Data.config.echoer.prefix,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.echoer.prefix = text
					print("Prefix set to", tostring(text))
				else
					print("Invalid prefix", tostring(text))
					self:SetText(Heimdall_Data.config.echoer.prefix)
				end
			end
		)
		echoerConfigFrame:Add(prefix, 2, 6)
	end

	-- Commander
	do
		local r, g, b, a = GetNextColor()
		local commanderConfigFrame = GridFrame.new("HeimdallCommanderConfig", UIParent, 12, 20)
		commanderConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(commanderConfigFrame, 10, 3)

		local title = CreateFancyText(
			"HeimdallCommanderConfigTitle",
			commanderConfigFrame.frame,
			shared._L("commander", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		commanderConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallCommanderConfigDebugButton",
			commanderConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.commander.debug = not Heimdall_Data.config.commander.debug
				return Heimdall_Data.config.commander.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.commander.debug)
		commanderConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallCommanderConfigEnableButton",
			commanderConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.commander.enabled = not Heimdall_Data.config.commander.enabled
				return Heimdall_Data.config.commander.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.commander.enabled)
		commanderConfigFrame:Add(enableButton, 1, 12)

		local channels = CreateBasicSmallEditBox(
			"HeimdallCommanderConfigChannels",
			commanderConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.commander.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.commander.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.commander.channels)
			end
		)
		commanderConfigFrame:Add(channels, 2, 6)

		local commander = CreateBasicSmallEditBox(
			"HeimdallCommanderConfigCommander",
			commanderConfigFrame.frame,
			shared._L("commander", Heimdall_Data.config.locale),
			Heimdall_Data.config.commander.commander,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.commander.commander = text
					print("Commander set to", tostring(text))
				else
					print("Invalid commander", tostring(text))
					self:SetText(Heimdall_Data.config.commander.commander)
				end
			end
		)
		commanderConfigFrame:Add(commander, 2, 6)

		local commands = CreateBasicSmallEditBox(
			"HeimdallCommanderConfigCommands",
			commanderConfigFrame.frame,
			shared._L("commands", Heimdall_Data.config.locale),
			MapKeyToString(Heimdall_Data.config.commander.commands, ", "),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.commander.commands = StringToMap(text, ",")
			end
		)
		commanderConfigFrame:Add(commands, 2, 12)
	end

	-- Macroer
	do
		local r, g, b, a = GetNextColor()
		local macroerConfigFrame = GridFrame.new("HeimdallMacroerConfig", UIParent, 12, 20)
		macroerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(macroerConfigFrame, 6, 3)

		local title = CreateFancyText(
			"HeimdallMacroerConfigTitle",
			macroerConfigFrame.frame,
			shared._L("macroer", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		macroerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallMacroerConfigDebugButton",
			macroerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.macroer.debug = not Heimdall_Data.config.macroer.debug
				return Heimdall_Data.config.macroer.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.macroer.debug)
		macroerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallCommanderConfigEnableButton",
			macroerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.macroer.enabled = not Heimdall_Data.config.macroer.enabled
				return Heimdall_Data.config.macroer.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.macroer.enabled)
		macroerConfigFrame:Add(enableButton, 1, 12)

		local priority = CreateBasicSmallEditBox(
			"HeimdallMacroerConfigPriority",
			macroerConfigFrame.frame,
			shared._L("priority", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.macroer.priority, ", "),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.macroer.priority = StringToArray(text, ",")
			end
		)
		macroerConfigFrame:Add(priority, 2, 12)
	end

	-- Combat Alerter
	do
		local r, g, b, a = GetNextColor()
		local combatAlerterConfigFrame = GridFrame.new("HeimdallCombatAlerterConfig", UIParent, 12, 20)
		combatAlerterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(combatAlerterConfigFrame, 5, 3)

		local title = CreateFancyText(
			"HeimdallCombatAlerterConfigTitle",
			combatAlerterConfigFrame.frame,
			shared._L("combatAlerter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		combatAlerterConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallCombatAlerterConfigDebugButton",
			combatAlerterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.combatAlerter.debug = not Heimdall_Data.config.combatAlerter.debug
				return Heimdall_Data.config.combatAlerter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.combatAlerter.debug)
		combatAlerterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallCombatAlerterConfigEnableButton",
			combatAlerterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.combatAlerter.enabled = not Heimdall_Data.config.combatAlerter.enabled
				return Heimdall_Data.config.combatAlerter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.combatAlerter.enabled)
		combatAlerterConfigFrame:Add(enableButton, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallCombatAlerterConfigChannels",
			combatAlerterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.combatAlerter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.combatAlerter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.combatAlerter.channels)
			end
		)
		combatAlerterConfigFrame:Add(channels, 2, 6)
	end

	-- Sniffer
	do
		local r, g, b, a = GetNextColor()
		local snifferConfigFrame = GridFrame.new("HeimdallSnifferConfig", UIParent, 12, 20)
		snifferConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(snifferConfigFrame, 8, 3)

		local title = CreateFancyText(
			"HeimdallSnifferConfigTitle",
			snifferConfigFrame.frame,
			shared._L("sniffer", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		snifferConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallSnifferConfigDebugButton",
			snifferConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.sniffer.debug = not Heimdall_Data.config.sniffer.debug
				return Heimdall_Data.config.sniffer.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.sniffer.debug)
		snifferConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallSnifferConfigEnableButton",
			snifferConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.sniffer.enabled = not Heimdall_Data.config.sniffer.enabled
				return Heimdall_Data.config.sniffer.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.sniffer.enabled)
		snifferConfigFrame:Add(enableButton, 2, 3)

		local stinkyButton = CreateBasicButton(
			"HeimdallSnifferConfigStinkyButton",
			snifferConfigFrame.frame,
			shared._L("stinky", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.sniffer.stinky = not Heimdall_Data.config.sniffer.stinky
				return Heimdall_Data.config.sniffer.stinky
			end
		)
		stinkyButton:UpdateColor(Heimdall_Data.config.sniffer.stinky)
		snifferConfigFrame:Add(stinkyButton, 2, 3)

		local channels = CreateBasicSmallEditBox(
			"HeimdallSnifferConfigChannels",
			snifferConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.sniffer.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.sniffer.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.sniffer.channels)
			end
		)
		snifferConfigFrame:Add(channels, 2, 6)

		local throttle = CreateBasicSmallEditBox(
			"HeimdallSnifferConfigThrottle",
			snifferConfigFrame.frame,
			shared._L("throttle", Heimdall_Data.config.locale),
			Heimdall_Data.config.sniffer.throttle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.sniffer.throttle = tonumber(text)
					print("Throttle set to", tostring(text))
				else
					print("Invalid throttle", tostring(text))
					self:SetText(Heimdall_Data.config.sniffer.throttle)
				end
			end
		)
		snifferConfigFrame:Add(throttle, 2, 6)

		local zoneOverride = CreateBasicSmallEditBox(
			"HeimdallSnifferConfigZoneOverride",
			snifferConfigFrame.frame,
			shared._L("zoneOverride", Heimdall_Data.config.locale),
			Heimdall_Data.config.sniffer.zoneOverride,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.sniffer.zoneOverride = text
					print("Zone override set to", tostring(text))
				else
					print("Invalid zone override", tostring(text))
					self:SetText(Heimdall_Data.config.sniffer.zoneOverride)
				end
			end
		)
		snifferConfigFrame:Add(zoneOverride, 2, 6)
	end

	-- BonkDetector
	do
		local r, g, b, a = GetNextColor()
		local bonkDetectorConfigFrame = GridFrame.new("HeimdallBonkDetectorConfig", UIParent, 12, 20)
		bonkDetectorConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(bonkDetectorConfigFrame, 7, 3)

		local title = CreateFancyText(
			"HeimdallBonkDetectorConfigTitle",
			bonkDetectorConfigFrame.frame,
			shared._L("bonkDetector", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		bonkDetectorConfigFrame:Add(title, 1, 8)

		local debugButton = CreateBasicButton(
			"HeimdallBonkDetectorConfigDebugButton",
			bonkDetectorConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.bonkDetector.debug = not Heimdall_Data.config.bonkDetector.debug
				return Heimdall_Data.config.bonkDetector.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.bonkDetector.debug)
		bonkDetectorConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallBonkDetectorConfigEnableButton",
			bonkDetectorConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.bonkDetector.enabled = not Heimdall_Data.config.bonkDetector.enabled
				return Heimdall_Data.config.bonkDetector.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.bonkDetector.enabled)
		bonkDetectorConfigFrame:Add(enableButton, 1, 12)

		local channels = CreateBasicSmallEditBox(
			"HeimdallBonkDetectorConfigChannels",
			bonkDetectorConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.bonkDetector.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.bonkDetector.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.bonkDetector.channels)
			end
		)
		bonkDetectorConfigFrame:Add(channels, 2, 6)

		local throttle = CreateBasicSmallEditBox(
			"HeimdallBonkDetectorConfigThrottle",
			bonkDetectorConfigFrame.frame,
			shared._L("throttle", Heimdall_Data.config.locale),
			Heimdall_Data.config.bonkDetector.throttle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.bonkDetector.throttle = tonumber(text)
					print("Throttle set to", tostring(text))
				else
					print("Invalid throttle", tostring(text))
					self:SetText(Heimdall_Data.config.bonkDetector.throttle)
				end
			end
		)
		bonkDetectorConfigFrame:Add(throttle, 2, 6)
	end

	-- Minimap Tagger
	do
		local r, g, b, a = GetNextColor()
		local minimapTaggerConfigFrame = GridFrame.new("HeimdallMinimapTaggerConfig", UIParent, 12, 20)
		minimapTaggerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(minimapTaggerConfigFrame, 18, 6)

		local title = CreateFancyText(
			"HeimdallMinimapTaggerConfigTitle",
			minimapTaggerConfigFrame.frame,
			shared._L("minimapTagger", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		minimapTaggerConfigFrame:Add(title, 1, 8)
		local debugButton = CreateBasicButton(
			"HeimdallMinimapTaggerConfigDebugButton",
			minimapTaggerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.debug = not Heimdall_Data.config.minimapTagger.debug
				return Heimdall_Data.config.minimapTagger.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.minimapTagger.debug)
		minimapTaggerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallMinimapTaggerConfigEnableButton",
			minimapTaggerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.enabled = not Heimdall_Data.config.minimapTagger.enabled
				return Heimdall_Data.config.minimapTagger.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.minimapTagger.enabled)
		minimapTaggerConfigFrame:Add(enableButton, 2, 6)

		local channels = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigChannels",
			minimapTaggerConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.minimapTagger.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.minimapTagger.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.minimapTagger.channels)
			end
		)
		minimapTaggerConfigFrame:Add(channels, 2, 3)

		local scale = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigScale",
			minimapTaggerConfigFrame.frame,
			shared._L("scale", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.scale,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.scale = tonumber(text)
					print("Scale set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(scale, 2, 3)

		--region Tag
		local tagSound = CreateBasicButton(
			"HeimdallMinimapTaggerConfigTagSound",
			minimapTaggerConfigFrame.frame,
			shared._L("tagSound", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.tagSound = not Heimdall_Data.config.minimapTagger.tagSound
				return Heimdall_Data.config.minimapTagger.tagSound
			end
		)
		tagSound:UpdateColor(Heimdall_Data.config.minimapTagger.tagSound)
		minimapTaggerConfigFrame:Add(tagSound, 2, 1)

		local tagTTL = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigTagTTL",
			minimapTaggerConfigFrame.frame,
			shared._L("ttl", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.tagTTL,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.tagTTL = tonumber(text)
					print("Tag TTL set to", tostring(text))
				else
					print("Invalid tag TTL", tostring(text))
					self:SetText(Heimdall_Data.config.minimapTagger.tagTTL)
				end
			end
		)
		minimapTaggerConfigFrame:Add(tagTTL, 2, 1)

		local tagSoundThrottle = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigTagSoundThrottle",
			minimapTaggerConfigFrame.frame,
			shared._L("soundThrottle", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.tagSoundThrottle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.tagSoundThrottle = tonumber(text)
					print("Tag sound throttle set to", tostring(text))
				else
					print("Invalid tag sound throttle", tostring(text))
					self:SetText(Heimdall_Data.config.minimapTagger.tagSoundThrottle)
				end
			end
		)
		minimapTaggerConfigFrame:Add(tagSoundThrottle, 2, 2)

		local tagSoundFile = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigTagSoundFile",
			minimapTaggerConfigFrame.frame,
			shared._L("soundFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.tagSoundFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.tagSoundFile = text
					print("Tag sound file set to", tostring(text))
				else
					print("Invalid tag sound file", tostring(text))
					self:SetText(Heimdall_Data.config.minimapTagger.tagSoundFile)
				end
			end
		)
		minimapTaggerConfigFrame:Add(tagSoundFile, 2, 4)

		local tagTexture = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigTagTexture",
			minimapTaggerConfigFrame.frame,
			shared._L("textureFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.tagTextureFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.tagTextureFile = text
					print("Tag texture file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(tagTexture, 2, 4)
		--endregion
		--region Alert
		local alertSound = CreateBasicButton(
			"HeimdallMinimapTaggerConfigAlertSound",
			minimapTaggerConfigFrame.frame,
			shared._L("alertSound", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.alertSound = not Heimdall_Data.config.minimapTagger.alertSound
				return Heimdall_Data.config.minimapTagger.alertSound
			end
		)
		alertSound:UpdateColor(Heimdall_Data.config.minimapTagger.alertSound)
		minimapTaggerConfigFrame:Add(alertSound, 2, 1)

		local alertTTL = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigAlertTTL",
			minimapTaggerConfigFrame.frame,
			shared._L("ttl", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.alertTTL,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.alertTTL = tonumber(text)
					print("Alert TTL set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(alertTTL, 2, 1)

		local alertSoundThrottle = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigAlertSoundThrottle",
			minimapTaggerConfigFrame.frame,
			shared._L("soundThrottle", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.alertSoundThrottle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.alertSoundThrottle = tonumber(text)
					print("Alert sound throttle set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(alertSoundThrottle, 2, 2)

		local alertSoundFile = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigAlertSoundFile",
			minimapTaggerConfigFrame.frame,
			shared._L("soundFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.alertSoundFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.alertSoundFile = text
					print("Alert sound file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(alertSoundFile, 2, 4)

		local alertTexture = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigAlertTexture",
			minimapTaggerConfigFrame.frame,
			shared._L("textureFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.alertTextureFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.alertTextureFile = text
					print("Alert texture file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(alertTexture, 2, 4)
		--endregion
		--region Combat
		local combatSound = CreateBasicButton(
			"HeimdallMinimapTaggerConfigCombatSound",
			minimapTaggerConfigFrame.frame,
			shared._L("combatSound", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.combatSound = not Heimdall_Data.config.minimapTagger.combatSound
				return Heimdall_Data.config.minimapTagger.combatSound
			end
		)
		combatSound:UpdateColor(Heimdall_Data.config.minimapTagger.combatSound)
		minimapTaggerConfigFrame:Add(combatSound, 2, 1)

		local combatTTL = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigCombatTTL",
			minimapTaggerConfigFrame.frame,
			shared._L("ttl", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.combatTTL,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.combatTTL = tonumber(text)
					print("Combat TTL set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(combatTTL, 2, 1)

		local combatSoundThrottle = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigCombatSoundThrottle",
			minimapTaggerConfigFrame.frame,
			shared._L("soundThrottle", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.combatSoundThrottle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.combatSoundThrottle = tonumber(text)
					print("Combat sound throttle set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(combatSoundThrottle, 2, 2)

		local combatSoundFile = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigCombatSoundFile",
			minimapTaggerConfigFrame.frame,
			shared._L("soundFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.combatSoundFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.combatSoundFile = text
					print("Combat sound file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(combatSoundFile, 2, 4)
		local combatTexture = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigCombatTexture",
			minimapTaggerConfigFrame.frame,
			shared._L("textureFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.combatTextureFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.combatTextureFile = text
					print("Combat texture file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(combatTexture, 2, 4)
		--endregion
		--region Help
		local helpSound = CreateBasicButton(
			"HeimdallMinimapTaggerConfigHelpSound",
			minimapTaggerConfigFrame.frame,
			shared._L("helpSound", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.minimapTagger.helpSound = not Heimdall_Data.config.minimapTagger.helpSound
				return Heimdall_Data.config.minimapTagger.helpSound
			end
		)
		helpSound:UpdateColor(Heimdall_Data.config.minimapTagger.helpSound)
		minimapTaggerConfigFrame:Add(helpSound, 2, 1)

		local helpTTL = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigHelpTTL",
			minimapTaggerConfigFrame.frame,
			shared._L("ttl", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.helpTTL,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.helpTTL = tonumber(text)
					print("Help TTL set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(helpTTL, 2, 1)

		local helpSoundThrottle = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigHelpSoundThrottle",
			minimapTaggerConfigFrame.frame,
			shared._L("soundThrottle", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.helpSoundThrottle,
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.minimapTagger.helpSoundThrottle = tonumber(text)
					print("Help sound throttle set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(helpSoundThrottle, 2, 2)

		local helpSoundFile = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigHelpSoundFile",
			minimapTaggerConfigFrame.frame,
			shared._L("soundFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.helpSoundFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.helpSoundFile = text
					print("Help sound file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(helpSoundFile, 2, 4)
		local helpTexture = CreateBasicSmallEditBox(
			"HeimdallMinimapTaggerConfigHelpTexture",
			minimapTaggerConfigFrame.frame,
			shared._L("textureFile", Heimdall_Data.config.locale),
			Heimdall_Data.config.minimapTagger.helpTextureFile,
			function(self)
				local text = self:GetText()
				if string.match(text, "%S+") then
					Heimdall_Data.config.minimapTagger.helpTextureFile = text
					print("Help texture file set to", tostring(text))
				end
			end
		)
		minimapTaggerConfigFrame:Add(helpTexture, 2, 4)
		--endregion
	end

	-- Noter
	do
		local r, g, b, a = GetNextColor()
		local noterConfigFrame = GridFrame.new("HeimdallNoterConfig", UIParent, 12, 20)
		noterConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(noterConfigFrame, 7, 3)

		local title = CreateFancyText(
			"HeimdallNoterConfigTitle",
			noterConfigFrame.frame,
			shared._L("noter", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		noterConfigFrame:Add(title, 1, 8)

		local debugButton = CreateBasicButton(
			"HeimdallNoterConfigDebugButton",
			noterConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.noter.debug = not Heimdall_Data.config.noter.debug
				return Heimdall_Data.config.noter.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.noter.debug)
		noterConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallNoterConfigEnableButton",
			noterConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.noter.enabled = not Heimdall_Data.config.noter.enabled
				return Heimdall_Data.config.noter.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.noter.enabled)
		noterConfigFrame:Add(enableButton, 1, 12)

		local channels = CreateBasicSmallEditBox(
			"HeimdallNoterConfigChannels",
			noterConfigFrame.frame,
			shared._L("channels", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.noter.channels or {}, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.noter.channels = StringToArray(text, ",")
				print("Channels set to")
				shared.dumpTable(Heimdall_Data.config.noter.channels)
			end
		)
		noterConfigFrame:Add(channels, 2, 6)

		local lastNotes = CreateBasicSmallEditBox(
			"HeimdallNoterConfigLastNotes",
			noterConfigFrame.frame,
			shared._L("lastNotes", Heimdall_Data.config.locale),
			tostring(Heimdall_Data.config.noter.lastNotes),
			function(self)
				local text = self:GetText()
				local value = tonumber(text)
				if value and value > 0 then
					Heimdall_Data.config.noter.lastNotes = value
					print("Last notes set to", value)
				else
					print("Invalid number of last notes", text)
					self:SetText(tostring(Heimdall_Data.config.noter.lastNotes))
				end
			end
		)
		noterConfigFrame:Add(lastNotes, 2, 6)
	end

	-- Network
	do
		local r, g, b, a = GetNextColor()
		local networkConfigFrame = GridFrame.new("HeimdallNetworkConfig", UIParent, 12, 20)
		networkConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(networkConfigFrame, 11, 3)

		local title = CreateFancyText(
			"HeimdallNetworkConfigTitle",
			networkConfigFrame.frame,
			shared._L("network", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		networkConfigFrame:Add(title, 1, 8)

		local debugButton = CreateBasicButton(
			"HeimdallNetworkConfigDebugButton",
			networkConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.network.debug = not Heimdall_Data.config.network.debug
				return Heimdall_Data.config.network.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.network.debug)
		networkConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallNetworkConfigEnableButton",
			networkConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.network.enabled = not Heimdall_Data.config.network.enabled
				return Heimdall_Data.config.network.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.network.enabled)
		networkConfigFrame:Add(enableButton, 1, 12)

		local members = CreateBasicBigEditBox(
			"HeimdallNetworkConfigMembers",
			networkConfigFrame.frame,
			shared._L("members", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.network.members, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.network.members = StringToArray(text, ",")
				print("Members set to", table.concat(Heimdall_Data.config.network.members, ","))
				self:SetText(table.concat(Heimdall_Data.config.network.members, ","))
			end
		)
		networkConfigFrame:Add(members, 5, 6)

		local updateInterval = CreateBasicSmallEditBox(
			"HeimdallNetworkConfigUpdateInterval",
			networkConfigFrame.frame,
			shared._L("updateInterval", Heimdall_Data.config.locale),
			tostring(Heimdall_Data.config.network.updateInterval),
			function(self)
				local text = self:GetText()
				if string.match(text, "%d+") then
					Heimdall_Data.config.network.updateInterval = tonumber(text)
					print("Update interval set to", tostring(text))
				else
					print("Invalid update interval", text)
					self:SetText(tostring(Heimdall_Data.config.network.updateInterval))
				end
			end
		)
		networkConfigFrame:Add(updateInterval, 2, 6)
	end

	-- NetworkMessenger
	do
		local r, g, b, a = GetNextColor()
		local networkMessengerConfigFrame = GridFrame.new("HeimdallNetworkMessengerConfig", UIParent, 12, 20)
		networkMessengerConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(networkMessengerConfigFrame, 5, 3)

		local title = CreateFancyText(
			"HeimdallNetworkMessengerConfigTitle",
			networkMessengerConfigFrame.frame,
			shared._L("networkMessenger", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		networkMessengerConfigFrame:Add(title, 1, 8)

		local debugButton = CreateBasicButton(
			"HeimdallNetworkMessengerConfigDebugButton",
			networkMessengerConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.networkMessenger.debug = not Heimdall_Data.config.networkMessenger.debug
				return Heimdall_Data.config.networkMessenger.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.networkMessenger.debug)
		networkMessengerConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallNetworkMessengerConfigEnableButton",
			networkMessengerConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.networkMessenger.enabled = not Heimdall_Data.config.networkMessenger.enabled
				return Heimdall_Data.config.networkMessenger.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.networkMessenger.enabled)
		networkMessengerConfigFrame:Add(enableButton, 2, 6)

		local interval = CreateBasicSmallEditBox(
			"HeimdallNetworkMessengerConfigInterval",
			networkMessengerConfigFrame.frame,
			shared._L("interval", Heimdall_Data.config.locale),
			tostring(Heimdall_Data.config.networkMessenger.interval),
			function(self)
				local text = self:GetText()
				if string.match(text, "^%d+%.?%d*$") then
					Heimdall_Data.config.networkMessenger.interval = tonumber(text)
					print("Interval set to", tostring(text))
				else
					print("Invalid interval", text)
					self:SetText(tostring(Heimdall_Data.config.networkMessenger.interval))
				end
			end
		)
		networkMessengerConfigFrame:Add(interval, 2, 6)
	end

	-- AchievementSniffer
	do
		local r, g, b, a = GetNextColor()
		local achievementSnifferConfigFrame = GridFrame.new("HeimdallAchievementSnifferConfig", UIParent, 12, 20)
		achievementSnifferConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(achievementSnifferConfigFrame, 14, 3)

		local title = CreateFancyText(
			"HeimdallAchievementSnifferConfigTitle",
			achievementSnifferConfigFrame.frame,
			shared._L("achievementSniffer", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		achievementSnifferConfigFrame:Add(title, 1, 8)

		local debugButton = CreateBasicButton(
			"HeimdallAchievementSnifferConfigDebugButton",
			achievementSnifferConfigFrame.frame,
			shared._L("debug", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.achievementSniffer.debug = not Heimdall_Data.config.achievementSniffer.debug
				return Heimdall_Data.config.achievementSniffer.debug
			end
		)
		debugButton:UpdateColor(Heimdall_Data.config.achievementSniffer.debug)
		achievementSnifferConfigFrame:Add(debugButton, 1, 4)

		local enableButton = CreateBasicButton(
			"HeimdallAchievementSnifferConfigEnableButton",
			achievementSnifferConfigFrame.frame,
			shared._L("enabled", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.achievementSniffer.enabled = not Heimdall_Data.config.achievementSniffer.enabled
				return Heimdall_Data.config.achievementSniffer.enabled
			end
		)
		enableButton:UpdateColor(Heimdall_Data.config.achievementSniffer.enabled)
		achievementSnifferConfigFrame:Add(enableButton, 2, 3)

		--local texture = CreateBasicSmallEditBox("HeimdallAchievementSnifferConfigTexture",
		--    achievementSnifferConfigFrame.frame, shared._L("texture", Heimdall_Data.config.locale),
		--    Heimdall_Data.config.achievementSniffer.texture,
		--    function(self)
		--        local text = self:GetText()
		--        Heimdall_Data.config.achievementSniffer.texture = text
		--    end)
		--achievementSnifferConfigFrame:Add(texture, 2, 3)

		--local offsetX = CreateBasicSmallEditBox("HeimdallAchievementSnifferConfigOffsetX",
		--    achievementSnifferConfigFrame.frame, shared._L("offsetX", Heimdall_Data.config.locale),
		--    tostring(Heimdall_Data.config.achievementSniffer.offsetX),
		--    function(self)
		--        local text = self:GetText()
		--        if string.match(text, "%d+") then
		--            Heimdall_Data.config.achievementSniffer.offsetX = tonumber(text)
		--            print("Offset X set to", tostring(text))
		--        else
		--            print("Invalid offset X", text)
		--            self:SetText(tostring(Heimdall_Data.config.achievementSniffer.offsetX))
		--        end
		--    end)
		--achievementSnifferConfigFrame:Add(offsetX, 2, 3)

		--local offsetY = CreateBasicSmallEditBox("HeimdallAchievementSnifferConfigOffsetY",
		--    achievementSnifferConfigFrame.frame, shared._L("offsetY", Heimdall_Data.config.locale),
		--    tostring(Heimdall_Data.config.achievementSniffer.offsetY),
		--    function(self)
		--        local text = self:GetText()
		--        if string.match(text, "%d+") then
		--            Heimdall_Data.config.achievementSniffer.offsetY = tonumber(text)
		--            print("Offset Y set to", tostring(text))
		--        else
		--            print("Invalid offset Y", text)
		--            self:SetText(tostring(Heimdall_Data.config.achievementSniffer.offsetY))
		--        end
		--    end)
		--achievementSnifferConfigFrame:Add(offsetY, 2, 3)

		local rescan = CreateBasicButton(
			"HeimdallAchievementSnifferConfigRescanButton",
			achievementSnifferConfigFrame.frame,
			shared._L("rescan", Heimdall_Data.config.locale),
			function()
				Heimdall_Data.config.achievementSniffer.rescan = not Heimdall_Data.config.achievementSniffer.rescan
				return Heimdall_Data.config.achievementSniffer.rescan
			end
		)
		rescan:UpdateColor(Heimdall_Data.config.achievementSniffer.rescan)
		achievementSnifferConfigFrame:Add(rescan, 2, 3)

		local scanInterval = CreateBasicSmallEditBox(
			"HeimdallAchievementSnifferConfigScanInterval",
			achievementSnifferConfigFrame.frame,
			shared._L("scanInterval", Heimdall_Data.config.locale),
			tostring(Heimdall_Data.config.achievementSniffer.scanInterval),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.achievementSniffer.scanInterval = tonumber(text)
			end
		)
		achievementSnifferConfigFrame:Add(scanInterval, 2, 3)

		--local iconScale = CreateBasicSmallEditBox("HeimdallAchievementSnifferConfigIconScale",
		--    achievementSnifferConfigFrame.frame, shared._L("iconScale", Heimdall_Data.config.locale),
		--    tostring(Heimdall_Data.config.achievementSniffer.iconScale),
		--    function(self)
		--        local text = self:GetText()
		--        Heimdall_Data.config.achievementSniffer.iconScale = tonumber(text)
		--    end)
		--achievementSnifferConfigFrame:Add(iconScale, 2, 3)
	end

	-- Addon prefix
	do
		local r, g, b, a = GetNextColor()
		local addonPrefixConfigFrame = GridFrame.new("HeimdallAddonPrefixConfig", UIParent, 12, 20)
		addonPrefixConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(addonPrefixConfigFrame, 5, 1)

		local title = CreateFancyText(
			"HeimdallAddonPrefixConfigTitle",
			addonPrefixConfigFrame.frame,
			shared._L("addonPrefix", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		addonPrefixConfigFrame:Add(title, 1, 12)

		local addonPrefix = CreateBasicSmallEditBox(
			"HeimdallAddonPrefixConfigAddonPrefix",
			addonPrefixConfigFrame.frame,
			shared._L("addonPrefix", Heimdall_Data.config.locale),
			Heimdall_Data.config.addonPrefix,
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.addonPrefix = text
			end
		)
		addonPrefixConfigFrame:Add(addonPrefix, 2, 12)
	end

	-- Whisper Notify
	do
		local r, g, b, a = GetNextColor()
		local whisperNotifyConfigFrame = GridFrame.new("HeimdallWhisperNotifyConfig", UIParent, 12, 20)
		whisperNotifyConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(whisperNotifyConfigFrame, 14, 1)

		local title = CreateFancyText(
			"HeimdallWhisperNotifyConfigTitle",
			whisperNotifyConfigFrame.frame,
			shared._L("whisperNotify", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		whisperNotifyConfigFrame:Add(title, 1, 12)

		local whisperNotify = CreateBasicBigEditBox(
			"HeimdallWhisperNotifyConfigWhisperNotify",
			whisperNotifyConfigFrame.frame,
			shared._L("whisperNotify", Heimdall_Data.config.locale),
			table.concat(Heimdall_Data.config.whisperNotify, "\n"),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.whisperNotify = StringToArray(text, "\n")
			end
		)
		whisperNotifyConfigFrame:Add(whisperNotify, 8, 12)
	end

	-- Stinkies
	do
		local r, g, b, a = GetNextColor()
		local stinkiesConfigFrame = GridFrame.new("HeimdallStinkiesConfig", UIParent, 12, 20)
		stinkiesConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(stinkiesConfigFrame, 28, 6)
		-- Why do 17 rows of content fit into a frame that is 14 rows?
		-- I don't know, at this point I can't be fucked to fix it, the display is minimally functional

		local title = CreateFancyText(
			"HeimdallStinkiesConfigTitle",
			stinkiesConfigFrame.frame,
			shared._L("stinkies", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		stinkiesConfigFrame:Add(title, 1, 12)

		local stinkies = CreateBasicBigEditBox(
			"HeimdallStinkiesConfigStinkies",
			stinkiesConfigFrame.frame,
			shared._L("stinkies", Heimdall_Data.config.locale),
			MapKeyToString(Heimdall_Data.config.stinkies, ","),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.stinkies = StringToMap(text, ",")
			end
		)
		stinkiesConfigFrame:Add(stinkies, 16, 12)
	end

	-- Channel locale
	do
		local r, g, b, a = GetNextColor()
		local channelLocaleConfigFrame = GridFrame.new("HeimdallChannelLocaleConfig", UIParent, 12, 20)
		channelLocaleConfigFrame.frame:SetBackdropColor(r, g, b, 0.3)
		configFrame:Add(channelLocaleConfigFrame, 14, 1)

		local title = CreateFancyText(
			"HeimdallChannelLocaleConfigTitle",
			channelLocaleConfigFrame.frame,
			shared._L("channelLocale", Heimdall_Data.config.locale),
			{ r, g, b, a }
		)
		channelLocaleConfigFrame:Add(title, 1, 12)

		local channelLocale = CreateBasicBigEditBox(
			"HeimdallChannelLocaleConfigChannelLocale",
			channelLocaleConfigFrame.frame,
			shared._L("channelLocale", Heimdall_Data.config.locale),
			MapToString(Heimdall_Data.config.channelLocale, ":", "\n"),
			function(self)
				local text = self:GetText()
				Heimdall_Data.config.channelLocale = MapFromString(text, ":", "\n")
			end
		)
		channelLocaleConfigFrame:Add(channelLocale, 8, 12)
	end

	--configFrame.frame:Hide()
	print("[Heimdall] Config loaded")
end

SlashCmdList["HEIMDALL_CONFIG"] = function() configFrame.frame:Show() end
SLASH_HEIMDALL_CONFIG1 = "/heimdall_config"
SLASH_HEIMDALL_CONFIG2 = "/hc"