/ShadowedUF_Options/config.lua

local Config = {}

local AceDialog, AceRegistry, AceGUI, SML, registered, options

local playerClass = select(2, UnitClass("player"))

local modifyUnits, globalConfig = {}, {}

local L = ShadowUF.L



ShadowUF.Config = Config



--[[

	The part that makes configuration a pain when you actually try is it gets unwieldly when you're adding special code to deal with

	showing help for certain cases, swapping tabs etc that makes it work smoothly.

	

	I'm going to have to split it out into separate files for each type to clean everything up but that takes time and I have other things

	I want to get done with first.

]]



local unitCategories = {

	player = {"player", "pet"},

	general = {"target", "targettarget", "targettargettarget", "focus", "focustarget", "pettarget"},

	party = {"party", "partypet", "partytarget"},

	raid = {"raid", "raidpet", "boss", "bosstarget", "maintank", "maintanktarget", "mainassist", "mainassisttarget"},

	arena = {"arena", "arenapet", "arenatarget"}}



local UNIT_DESC = {

	["boss"] = L["Boss units are for only certain fights, such as Blood Princes or the Gunship battle, you will not see them for every boss fight."],

	["mainassist"] = L["Main Assists's are set by the Blizzard Main Assist system or mods that use them such as oRA3."],

	["maintank"] = L["Main Tank's are set by the Blizzard Main Tank system or mods that use them such as oRA3."],

}



local PAGE_DESC = {

	["general"] = L["General configuration to all enabled units."],

	["enableUnits"] = L["Various units can be enabled through this page, such as raid or party targets."],

	["hideBlizzard"] = L["Hiding and showing various aspects of the default UI such as the player buff frames."],

	["units"] = L["Configuration to specific unit frames."],

	["visibility"] = L["Disabling unit modules in various instances."],

	["tags"] = L["Advanced tag management, allows you to add your own custom tags."],

	["filter"] = L["Simple aura filtering by whitelists and blacklists."],

}

local INDICATOR_NAMES = {["leader"] = L["Leader"], ["lfdRole"] = L["Dungeon role"], ["masterLoot"] = L["Master looter"], ["pvp"] = L["PvP Flag"], ["raidTarget"] = L["Raid target"], ["ready"] = L["Ready status"], ["role"] = L["Raid role"], ["status"] = L["Combat status"], ["class"] = L["Class icon"], ["resurrect"] = L["Resurrect status"], ["phase"] = L["Phase status"]}

local AREA_NAMES = {["arena"] = L["Arenas"],["none"] = L["Everywhere else"], ["party"] = L["Party instances"], ["pvp"] = L["Battlegrounds"], ["raid"] = L["Raid instances"]}

local INDICATOR_DESC = {

		["leader"] = L["Crown indicator for group leaders."], ["lfdRole"] = L["Role the unit is playing in dungeons formed through the Looking For Dungeon system."],

		["masterLoot"] = L["Bag indicator for master looters."], ["pvp"] = L["PVP flag indicator, Horde for Horde flagged pvpers and Alliance for Alliance flagged pvpers."],

		["raidTarget"] = L["Raid target indicator."], ["ready"] = L["Ready status of group members."],

		["role"] = L["Raid role indicator, adds a shield indicator for main tanks and a sword icon for main assists."], ["status"] = L["Status indicator, shows if the unit is currently in combat. For the player it will also show if you are rested."], ["class"] = L["Class icon for players."]}

local TAG_GROUPS = {["classification"] = L["Classifications"], ["health"] = L["Health"], ["misc"] = L["Miscellaneous"], ["playerthreat"] = L["Player threat"], ["power"] = L["Power"], ["status"] = L["Status"], ["threat"] = L["Threat"], ["raid"] = L["Raid"], ["absorb"] = L["Absorb"]}



local pointPositions = {["BOTTOM"] = L["Bottom"], ["TOP"] = L["Top"], ["LEFT"] = L["Left"], ["RIGHT"] = L["Right"], ["TOPLEFT"] = L["Top Left"], ["TOPRIGHT"] = L["Top Right"], ["BOTTOMLEFT"] = L["Bottom Left"], ["BOTTOMRIGHT"] = L["Bottom Right"], ["CENTER"] = L["Center"]}

local positionList = {["C"] = L["Center"], ["RT"] = L["Right Top"], ["RC"] = L["Right Center"], ["RB"] = L["Right Bottom"], ["LT"] = L["Left Top"], ["LC"] = L["Left Center"], ["LB"] = L["Left Bottom"], ["BL"] = L["Bottom Left"], ["BC"] = L["Bottom Center"], ["BR"] = L["Bottom Right"], ["TR"] = L["Top Right"], ["TC"] = L["Top Center"], ["TL"] = L["Top Left"]}



local unitOrder = {}

for order, unit in pairs(ShadowUF.unitList) do unitOrder[unit] = order end

local fullReload = {["bars"] = true, ["auras"] = true, ["backdrop"] = true, ["font"] = true, ["classColors"] = true, ["powerColors"] = true, ["healthColors"] = true, ["xpColors"] = true, ["omnicc"] = true}

local quickIDMap = {}



-- Helper functions

local function getPageDescription(info)

	return PAGE_DESC[info[#(info)]]

end



local function getFrameName(unit)

	if( unit == "raidpet" or unit == "raid" or unit == "party" or unit == "maintank" or unit == "mainassist" or unit == "boss" or unit == "arena" ) then

		return string.format("#SUFHeader%s", unit)

	end

	

	return string.format("#SUFUnit%s", unit)

end



local anchorList = {}

local function getAnchorParents(info)

	local unit = info[2]

	for k in pairs(anchorList) do anchorList[k] = nil end

	

	if( ShadowUF.Units.childUnits[unit] ) then

		anchorList["$parent"] = string.format(L["%s member"], L.units[ShadowUF.Units.childUnits[unit]])

		return anchorList

	end

	

	anchorList["UIParent"] = L["Screen"]

	

	-- Don't let a frame anchor to a frame thats anchored to it already (Stop infinite loops-o-doom)

	local currentName = getFrameName(unit)

	for _, unitID in pairs(ShadowUF.unitList) do

		if( unitID ~= unit and ShadowUF.db.profile.positions[unitID] and ShadowUF.db.profile.positions[unitID].anchorTo ~= currentName ) then

			anchorList[getFrameName(unitID)] = string.format(L["%s frames"], L.units[unitID] or unitID)

		end

	end

	

	return anchorList

end



local function selectDialogGroup(group, key)

	AceDialog.Status.ShadowedUF.children[group].status.groups.selected = key

	AceRegistry:NotifyChange("ShadowedUF")

end



local function selectTabGroup(group, subGroup, key)

	AceDialog.Status.ShadowedUF.children[group].status.groups.selected = subGroup

	AceDialog.Status.ShadowedUF.children[group].children[subGroup].status.groups.selected = key

	AceRegistry:NotifyChange("ShadowedUF")

end

							

local function hideAdvancedOption(info)

	return not ShadowUF.db.profile.advanced

end



local function hideBasicOption(info)

	return ShadowUF.db.profile.advanced

end



local function isUnitDisabled(info)

	local unit = info[#(info)]

	local enabled = ShadowUF.db.profile.units[unit].enabled

	for _, visibility in pairs(ShadowUF.db.profile.visibility) do

		if( visibility[unit] ) then

			enabled = visibility[unit]

			break

		end

	end

	

	return not enabled

end



local function mergeTables(parent, child)

	for key, value in pairs(child) do

		if( type(parent[key]) == "table" ) then

			parent[key] = mergeTables(parent[key], value)

		elseif( type(value) == "table" ) then

			parent[key] = CopyTable(value)

		elseif( parent[key] == nil ) then

			parent[key] = value

		end

	end

	

	return parent

end



local function getName(info)

	local key = info[#(info)]

	if( ShadowUF.modules[key] and ShadowUF.modules[key].moduleName ) then

		return ShadowUF.modules[key].moduleName

	end

	

	return LOCALIZED_CLASS_NAMES_MALE[key] or INDICATOR_NAMES[key] or L.units[key] or TAG_GROUPS[key] or L[key]

end



local function getUnitOrder(info)

	return unitOrder[info[#(info)]]

end



local function isModifiersSet(info)

	if( info[2] ~= "global" ) then return false end

	for k in pairs(modifyUnits) do return false end

	return true

end



-- These are for setting simple options like bars.texture = "Default" or locked = true

local function set(info, value)

	local cat, key = string.split(".", info.arg)

	if( key == "$key" ) then key = info[#(info)] end

	

	if( not key ) then

		ShadowUF.db.profile[cat] = value

	else

		ShadowUF.db.profile[cat][key] = value

	end

	

	if( cat and fullReload[cat] ) then

		ShadowUF.Layout:CheckMedia()

		ShadowUF.Layout:Reload()

	end

end



local function get(info)

	local cat, key = string.split(".", info.arg)

	if( key == "$key" ) then key = info[#(info)] end

	if( not key ) then

		return ShadowUF.db.profile[cat]

	else

		return ShadowUF.db.profile[cat][key]

	end

end



local function setColor(info, r, g, b, a)

	local color = get(info)

	color.r, color.g, color.b, color.a = r, g, b, a

	set(info, color)

end



local function getColor(info)

	local color = get(info)

	return color.r, color.g, color.b, color.a

end



-- These are for setting complex options like units.player.auras.buffs.enabled = true or units.player.portrait.enabled = true

local function setVariable(unit, moduleKey, moduleSubKey, key, value)

	local configTable = unit == "global" and globalConfig or ShadowUF.db.profile.units[unit]

		

	-- For setting options like units.player.auras.buffs.enabled = true

	if( moduleKey and moduleSubKey and configTable[moduleKey][moduleSubKey] ) then

		configTable[moduleKey][moduleSubKey][key] = value

		ShadowUF.Layout:Reload(unit)

	-- For setting options like units.player.portrait.enabled = true

	elseif( moduleKey and not moduleSubKey and configTable[moduleKey] ) then

		configTable[moduleKey][key] = value

		ShadowUF.Layout:Reload(unit)

	-- For setting options like units.player.height = 50

	elseif( not moduleKey and not moduleSubKey ) then

		configTable[key] = value

		ShadowUF.Layout:Reload(unit)

	end

end



local function specialRestricted(unit, moduleKey, moduleSubKey, key)

	if( ShadowUF.fakeUnits[unit] and ( key == "colorAggro" or key == "aggro" or moduleKey == "incHeal" or moduleKey == "castBar" ) ) then

		return true

	elseif( moduleKey == "healthBar" and unit == "player" and key == "reaction" ) then

		return true

	end

end



local function setDirectUnit(unit, moduleKey, moduleSubKey, key, value)

	if( unit == "global" ) then

		for unit in pairs(modifyUnits) do

			if( not specialRestricted(unit, moduleKey, moduleSubKey, key) ) then

				setVariable(unit, moduleKey, moduleSubKey, key, value)

			end

		end

		

		setVariable("global", moduleKey, moduleSubKey, key, value)

	else

		setVariable(unit, moduleKey, moduleSubKey, key, value)

	end

end



local function setUnit(info, value)

	local unit = info[2]

	-- auras, buffs, enabled / text, 1, text / portrait, enabled

	local moduleKey, moduleSubKey, key = string.split(".", info.arg)

	if( not moduleSubKey ) then key = moduleKey moduleKey = nil end

	if( moduleSubKey and not key ) then key = moduleSubKey moduleSubKey = nil end

	if( moduleSubKey == "$parent" ) then moduleSubKey = info[#(info) - 1] end

	if( moduleKey == "$parent" ) then moduleKey = info[#(info) - 1] end

	if( tonumber(moduleSubKey) ) then moduleSubKey = tonumber(moduleSubKey) end

	

	setDirectUnit(unit, moduleKey, moduleSubKey, key, value)

end



local function getVariable(unit, moduleKey, moduleSubKey, key)

	local configTbl = unit == "global" and globalConfig or ShadowUF.db.profile.units[unit]

	if( moduleKey and moduleSubKey ) then

		return configTbl[moduleKey][moduleSubKey] and configTbl[moduleKey][moduleSubKey][key]

	elseif( moduleKey and not moduleSubKey ) then

		return configTbl[moduleKey] and configTbl[moduleKey][key]

	end



	return configTbl[key]

end



local function getUnit(info)

	local moduleKey, moduleSubKey, key = string.split(".", info.arg)

	if( not moduleSubKey ) then key = moduleKey moduleKey = nil end

	if( moduleSubKey and not key ) then key = moduleSubKey moduleSubKey = nil end

	if( moduleSubKey == "$parent" ) then moduleSubKey = info[#(info) - 1] end

	if( moduleKey == "$parent" ) then moduleKey = info[#(info) - 1] end

	if( tonumber(moduleSubKey) ) then moduleSubKey = tonumber(moduleSubKey) end

	

	return getVariable(info[2], moduleKey, moduleSubKey, key)

end



-- Tag functions

local function getTagName(info)

	local tag = info[#(info)]

	if( ShadowUF.db.profile.tags[tag] and ShadowUF.db.profile.tags[tag].name ) then

		return ShadowUF.db.profile.tags[tag].name

	end

	

	return ShadowUF.Tags.defaultNames[tag] or tag

end



local function getTagHelp(info)

	local tag = info[#(info)]

	return ShadowUF.Tags.defaultHelp[tag] or ShadowUF.db.profile.tags[tag] and ShadowUF.db.profile.tags[tag].help

end



-- Module functions

local function hideRestrictedOption(info)

	local unit = type(info.arg) == "number" and info[#(info) - info.arg] or info[2]

	local key = info[#(info)]

	if( ShadowUF.modules[key] and ShadowUF.modules[key].moduleClass and ShadowUF.modules[key].moduleClass ~= playerClass ) then

		return true

	elseif( key == "incHeal" and not ShadowUF.modules.incHeal ) then

		return true

	-- Non-standard units do not support color by aggro or incoming heal

	elseif( key == "colorAggro" or key == "incHeal" or key == "aggro" ) then

		return string.match(unit, "%w+target" )

	-- Fall back for indicators, no variable table so it shouldn't be shown

	elseif( info[#(info) - 1] == "indicators" ) then

		if( ( unit == "global" and not globalConfig.indicators[key] ) or ( unit ~= "global" and not ShadowUF.db.profile.units[unit].indicators[key] ) ) then

			return true

		end

	-- Fall back, no variable table so it shouldn't be shown

	elseif( ( unit == "global" and not globalConfig[key] ) or ( unit ~= "global" and not ShadowUF.db.profile.units[unit][key] ) ) then

		return true

	end

	

	return false

end



local function getModuleOrder(info)

	local key = info[#(info)]

	return key == "healthBar" and 1 or key == "powerBar" and 2 or key == "castBar" and 3 or 4

end



-- Expose these for modules

Config.getAnchorParents = getAnchorParents

Config.hideAdvancedOption = hideAdvancedOption

Config.isUnitDisabled = isUnitDisabled

Config.selectDialogGroup = selectDialogGroup

Config.selectTabGroup = selectTabGroup

Config.getName = getName

Config.getUnitOrder = getUnitOrder

Config.isModifiersSet = isModifiersSet

Config.set = set

Config.get = get

Config.setUnit = setUnit

Config.setVariable = setVariable

Config.getUnit = getUnit

Config.getVariable = getVariable

Config.hideRestrictedOption = hideRestrictedOption

Config.hideBasicOption = hideBasicOption





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

-- GENERAL CONFIGURATION

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

local function loadGeneralOptions()

	SML = SML or LibStub:GetLibrary("LibSharedMedia-3.0")

	

	local MediaList = {}

	local function getMediaData(info)

		local mediaType = info[#(info)]



		MediaList[mediaType] = MediaList[mediaType] or {}



		for k in pairs(MediaList[mediaType]) do	MediaList[mediaType][k] = nil end

		for _, name in pairs(SML:List(mediaType)) do

			MediaList[mediaType][name] = name

		end

		

		return MediaList[mediaType]

	end

	



	local barModules = {}

	for	key, module in pairs(ShadowUF.modules) do

		if( module.moduleHasBar ) then

			barModules["$" .. key] = module.moduleName

		end

	end

	

	local addTextParent = {

		order = 4,

		type = "group",

		inline = true,

		name = function(info) return barModules[info[#(info)]] or string.sub(info[#(info)], 2) end,

		hidden = function(info)

			for _, text in pairs(ShadowUF.db.profile.units.player.text) do

				if( text.anchorTo == info[#(info)] ) then

					return false

				end

			end

			

			return true

		end,

		args = {},

	}

	

	local addTextLabel = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) end,

		type = "description",

		width = "",

		fontSize = "medium",

		hidden = function(info)

			local id = tonumber(string.match(info[#(info)], "(%d+)"))

			if( not getVariable("player", "text", nil, id) ) then return true end

			return getVariable("player", "text", id, "anchorTo") ~= info[#(info) - 1]

		end,

		name = function(info)

			return getVariable("player", "text", tonumber(string.match(info[#(info)], "(%d+)")), "name")

		end,

	}



	local addTextSep = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) + 0.75 end,

		type = "description",

		width = "full",

		hidden = function(info)

			local id = tonumber(string.match(info[#(info)], "(%d+)"))

			if( not getVariable("player", "text", nil, id) ) then return true end

			return getVariable("player", "text", id, "anchorTo") ~= info[#(info) - 1]

		end,

		name = "",

	}

	

	local addText = {

		order = function(info) return info[#(info)] + 0.5 end,

		type = "execute",

		width = "half",

		name = L["Delete"],

		hidden = function(info)

			local id = tonumber(info[#(info)])

			if( not getVariable("player", "text", nil, id) ) then return true end

			return getVariable("player", "text", id, "anchorTo") ~= info[#(info) - 1]

		end,

		disabled = function(info) return tonumber(info[#(info)]) <= 5 end,

		confirmText = L["Are you sure you want to delete this text? All settings for it will be deleted."],

		confirm = true,

		func = function(info)

			local id = tonumber(info[#(info)])

			for _, unit in pairs(ShadowUF.unitList) do

				table.remove(ShadowUF.db.profile.units[unit].text, id)

			end

			

			addTextParent.args[info[#(info)]] = nil

			ShadowUF.Layout:Reload()

		end,

	}



	local function validateSpell(info, spell)

		if( spell and spell ~= "" and not GetSpellInfo(spell) ) then

			return string.format(L["Invalid spell \"%s\" entered."], spell or "")

		end

		

		return true

	end

	

	local function setRange(info, spell)

		ShadowUF.db.profile.range[info[#(info)] .. playerClass] = spell and spell ~= "" and spell or nil

		ShadowUF.Layout:Reload()

	end

	

	local function getRange(info, spell)

		local spell = ShadowUF.db.profile.range[info[#(info)] .. playerClass]

		return spell and spell ~= "" and spell or ShadowUF.modules.range[info[#(info)]][playerClass]

	end

								

	local textData = {}

	

	local function writeTable(tbl)

		local data = ""

		for key, value in pairs(tbl) do

			local valueType = type(value)

			

			-- Wrap the key in brackets if it's a number

			if( type(key) == "number" ) then

				key = string.format("[%s]", key)

			-- Wrap the string with quotes if it has a space in it

			elseif( string.match(key, "[%p%s%c]") ) then

				key = string.format("['%s']", string.gsub(key, "'", "\\'"))

			end

			

			-- foo = {bar = 5}

			if( valueType == "table" ) then

				data = string.format("%s%s=%s;", data, key, writeTable(value))

			-- foo = true / foo = 5

			elseif( valueType == "number" or valueType == "boolean" ) then

				data = string.format("%s%s=%s;", data, key, tostring(value))

			-- foo = "bar"

			else

				data = string.format("%s%s='%s';", data, key, string.gsub(tostring(value), "'", "\\'"))

			end

		end

		

		return "{" .. data .. "}"

	end

		

	local layoutData = {positions = true, visibility = true, modules = false}

	local layoutManager = {

		type = "group",

		order = 7,

		name = L["Layout manager"],

		childGroups = "tab",

		hidden = hideAdvancedOption,

		args = {

			import = {

				order = 1,

				type = "group",

				name = L["Import"],

				hidden = false,

				args = {

					help = {

						order = 1,

						type = "group",

						inline = true,

						name = function(info) return layoutData.error and L["Error"] or L["Help"] end,

						args = {

							help = {

								order = 1,

								type = "description",

								name = function(info)

									if( ShadowUF.db:GetCurrentProfile() == "Import Backup" ) then

										return L["Your active layout is the profile used for import backup, this cannot be overwritten by an import. Change your profiles to something else and try again."]

									end

								

									return layoutData.error or L["You can import another Shadowed Unit Frame users configuration by entering the export code they gave you below. This will backup your old layout to \"Import Backup\".|n|nIt will take 30-60 seconds for it to load your layout when you paste it in, please by patient."]

								end

							},

						},

					},

					positions = {

						order = 2,

						type = "toggle",

						name = L["Import unit frame positions"],

						set = function(info, value) layoutData[info[#(info)]] = value end,

						get = function(info) return layoutData[info[#(info)]] end,

						width = "double",

					},

					visibility = {

						order = 3,

						type = "toggle",

						name = L["Import visibility settings"],

						set = function(info, value) layoutData[info[#(info)]] = value end,

						get = function(info) return layoutData[info[#(info)]] end,

						width = "double",

					},

					modules = {

						order = 4,

						type = "toggle",

						name = L["Import non-standard module settings"],

						desc = L["Will not import settings of modules that are not included with Shadowed Unit Frames by default."],

						set = function(info, value) layoutData[info[#(info)]] = value end,

						get = function(info) return layoutData[info[#(info)]] end,

						width = "double",

					},

					import = {

						order = 5,

						type = "input",

						name = L["Code"],

						multiline = true,

						width = "full",

						get = false,

						disabled = function() return ShadowUF.db:GetCurrentProfile() == "Import Backup" end,

						set = function(info, import)

							local layout, err = loadstring(string.format([[return %s]], import))

							if( err ) then

								layoutData.error = string.format(L["Failed to import layout, error:|n|n%s"], err)

								return

							end

							

							layout = layout()

							

							-- Strip position settings

							if( not layoutData.positions ) then

								layout.positions = nil

							end

							

							-- Strip visibility settings

							if( not layoutData.visibility ) then

								layout.visibility = nil

							end

							

							-- Strip any units we don't have included by default

							for unit in pairs(layout.units) do

								if( not ShadowUF.defaults.profile.units[unit] ) then

									layout.units[unit] = nil

								end

							end

							

							-- Strip module settings that aren't with SUF by default

							if( not layoutData.modules ) then

								local validModules = {["healthBar"] = true, ["powerBar"] = true, ["portrait"] = true, ["range"] = true, ["text"] = true, ["indicators"] = true, ["auras"] = true, ["incHeal"] = true, ["castBar"] = true, ["combatText"] = true, ["highlight"] = true, ["runeBar"] = true, ["totemBar"] = true, ["xpBar"] = true, ["fader"] = true, ["comboPoints"] = true, ["eclipseBar"] = true, ["soulShards"] = true, ["holyPower"] = true, ["altPowerBar"] = true}

								for _, unitData in pairs(layout.units) do

									for key, data in pairs(unitData) do

										if( type(data) == "table" and not validModules[key] and ShadowUF.modules[key] ) then

											unitData[key] = nil

										end

									end

								end

							end

							

							-- Check if we need move over the visibility and positions info

							layout.positions = layout.positions or CopyTable(ShadowUF.db.profile.positions)

							layout.visibility = layout.visibility or CopyTable(ShadowUF.db.profile.positions)



							-- Now backup the profile

							local currentLayout = ShadowUF.db:GetCurrentProfile()

							ShadowUF.layoutImporting = true

							ShadowUF.db:SetProfile("Import Backup")

							ShadowUF.db:CopyProfile(currentLayout)

							ShadowUF.db:SetProfile(currentLayout)

							ShadowUF.db:ResetProfile()

							ShadowUF.layoutImporting = nil

														

							-- Overwrite everything we did import

							ShadowUF:LoadDefaultLayout()

							for key, data in pairs(layout) do

								if( type(data) == "table" ) then

									ShadowUF.db.profile[key] = CopyTable(data)

								else

									ShadowUF.db.profile[key] = data

								end

							end

							

							ShadowUF:ProfilesChanged()

						end,

					},

				},

			},

			export = {

				order = 2,

				type = "group",

				name = L["Export"],

				hidden = false,

				args = {

					help = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Help"],

						args = {

							help = {

								order = 1,

								type = "description",

								name = L["After you hit export, you can give the below code to other Shadowed Unit Frames users and they will get your exact layout."],

							},

						},

					},

					doExport = {

						order = 2,

						type = "execute",

						name = L["Export"],

						func = function(info)

							layoutData.export = writeTable(ShadowUF.db.profile)

						end,

					},

					export = {

						order = 3,

						type = "input",

						name = L["Code"],

						multiline = true,

						width = "full",

						set = false,

						get = function(info) return layoutData[info[#(info)]] end,

					},

				},

			},

		},

	}

	

	options.args.general = {

		type = "group",

		childGroups = "tab",

		name = L["General"],

		args = {

			general = {

				type = "group",

				order = 1,

				name = L["General"],

				set = set,

				get = get,

				args = {

					general = {

						order = 1,

						type = "group",

						inline = true,

						name = L["General"],

						args = {

							locked = {

								order = 1,

								type = "toggle",

								name = L["Lock frames"],

								desc = L["Enables configuration mode, letting you move and giving you example frames to setup."],

								set = function(info, value)

									set(info, value)

									ShadowUF.modules.movers:Update()

								end,

								arg = "locked",

							},

							sep = {

								order = 1.5,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							advanced = {

								order = 2,

								type = "toggle",

								name = L["Advanced"],

								desc = L["Enabling advanced settings will give you access to more configuration options. This is meant for people who want to tweak every single thing, and should not be enabled by default as it increases the options."],

								arg = "advanced",

							},

							omnicc = {

								order = 2.5,

								type = "toggle",

								name = L["Disable OmniCC"],

								desc = L["Disables showing OmniCC timers in all Shadowed Unit Frame auras."],

								arg = "omnicc",

								hidden = hideAdvancedOption,

							},

							hideCombat = {

								order = 3,

								type = "toggle",

								name = L["Hide tooltips in combat"],

								desc = L["Prevents unit tooltips from showing while in combat."],

								arg = "tooltipCombat",

							},

							auraBorder = {

								order = 5,

								type = "select",

								name = L["Aura border style"],

								desc = L["Style of borders to show for all auras."],

								values = {["dark"] = L["Dark"], ["light"] = L["Light"], ["blizzard"] = L["Blizzard"], [""] = L["None"]},

								arg = "auras.borderType",

							},

							statusbar = {

								order = 6,

								type = "select",

								name = L["Bar texture"],

								dialogControl = "LSM30_Statusbar",

								values = getMediaData,

								arg = "bars.texture",

							},

							spacing = {

								order = 7,

								type = "range",

								name = L["Bar spacing"],

								desc = L["How much spacing should be provided between all of the bars inside a unit frame, negative values move them farther apart, positive values bring them closer together. 0 for no spacing."],

								min = -10, max = 10, step = 0.05, softMin = -5, softMax = 5,

								arg = "bars.spacing",

								hidden = hideAdvancedOption,

							},

						},

					},

					backdrop = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Background/border"],

						args = {

							backgroundColor = {

								order = 1,

								type = "color",

								name = L["Background color"],

								hasAlpha = true,

								set = setColor,

								get = getColor,

								arg = "backdrop.backgroundColor",

							},

							borderColor = {

								order = 2,

								type = "color",

								name = L["Border color"],

								hasAlpha = true,

								set = setColor,

								get = getColor,

								arg = "backdrop.borderColor",

							},

							sep = {

								order = 3,

								type = "description",

								name = "",

								width = "full",

							},

							background = {

								order = 4,

								type = "select",

								name = L["Background"],

								dialogControl = "LSM30_Background",

								values = getMediaData,

								arg = "backdrop.backgroundTexture",

							},

							border = {

								order = 5,

								type = "select",

								name = L["Border"],

								dialogControl = "LSM30_Border",

								values = getMediaData,

								arg = "backdrop.borderTexture",

							},

							inset = {

								order = 5.5,

								type = "range",

								name = L["Inset"],

								desc = L["How far the background should be from the unit frame border."],

								min = -10, max = 10, step = 1,

								hidden = hideAdvancedOption,

								arg = "backdrop.inset",

							},

							sep2 = {

								order = 6,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							edgeSize = {

								order = 7,

								type = "range",

								name = L["Edge size"],

								desc = L["How large the edges should be."],

								hidden = hideAdvancedOption,

								min = 0, max = 20, step = 1,

								arg = "backdrop.edgeSize",

							},

							tileSize = {

								order = 8,

								type = "range",

								name = L["Tile size"],

								desc = L["How large the background should tile"],

								hidden = hideAdvancedOption,

								min = 0, max = 20, step = 1,

								arg = "backdrop.tileSize",

							},

							clip = {

								order = 9,

								type = "range",

								name = L["Clip"],

								desc = L["How close the frame should clip with the border."],

								hidden = hideAdvancedOption,

								min = 0, max = 20, step = 1,

								arg = "backdrop.clip",

							},

						},

					},

					font = {

						order = 3,

						type = "group",

						inline = true,

						name = L["Font"],

						args = {

							color = {

								order = 1,

								type = "color",

								name = L["Default color"],

								desc = L["Default font color, any color tags inside individual tag texts will override this."],

								hasAlpha = true,

								set = setColor,

								get = getColor,

								arg = "font.color",

								hidden = hideAdvancedOption,

							},

							sep = {order = 1.25, type = "description", name = "", hidden = hideAdvancedOption},

							font = {

								order = 1.5,

								type = "select",

								name = L["Font"],

								dialogControl = "LSM30_Font",

								values = getMediaData,

								arg = "font.name",

							},

							size = {

								order = 2,

								type = "range",

								name = L["Size"],

								min = 1, max = 50, step = 1, softMin = 1, softMax = 20,

								arg = "font.size",

							},

							outline = {

								order = 3,

								type = "select",

								name = L["Outline"],

								values = {["OUTLINE"] = L["Thin outline"], ["THICKOUTLINE"] = L["Thick outline"], ["MONOCHROME"] = L["Monochrome"], [""] = L["None"]},

								arg = "font.extra",

								hidden = hideAdvancedOption,

							},

						},

					},

					bar = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Bars"],

						hidden = hideAdvancedOption,

						args = {

							override = {

								order = 0,

								type = "toggle",

								name = L["Override color"],

								desc = L["Forces a static color to be used for the background of all bars"],

								set = function(info, value)

									if( value and not ShadowUF.db.profile.bars.backgroundColor ) then

										ShadowUF.db.profile.bars.backgroundColor = {r = 0, g = 0, b = 0}

									elseif( not value ) then

										ShadowUF.db.profile.bars.backgroundColor = nil

									end

									

									ShadowUF.Layout:Reload()

								end,

								get = function(info)

									return ShadowUF.db.profile.bars.backgroundColor and true or false

								end,

							},

							color = {

								order = 1,

								type = "color",

								name = L["Background color"],

								desc = L["This will override all background colorings for bars including custom set ones."],

								set = setColor,

								get = function(info)

									if( not ShadowUF.db.profile.bars.backgroundColor ) then

										return {r = 0, g = 0, b = 0}

									end

									

									return getColor(info)

								end,

								disabled = function(info) return not ShadowUF.db.profile.bars.backgroundColor end,

								arg = "bars.backgroundColor",

							},

							sep = { order = 2, type = "description", name = "", width = "full"},

							barAlpha = {

								order = 3,

								type = "range",

								name = L["Bar alpha"],

								desc = L["Alpha to use for bar."],

								arg = "bars.alpha",

								min = 0, max = 1, step = 0.05,

								isPercent = true

							},

							backgroundAlpha = {

								order = 4,

								type = "range",

								name = L["Background alpha"],

								desc = L["Alpha to use for bar backgrounds."],

								arg = "bars.backgroundAlpha",

								min = 0, max = 1, step = 0.05,

								isPercent = true

							},

						},

					},

					range = {

						order = 5,

						type = "group",

						inline = true,

						name = L["Range spells"],

						args = {

							friendly = {

								order = 0,

								type = "input",

								name = L["Friendly spell"],

								desc = L["Name of a friendly spell to check range on friendlies.|n|nThis is automatically set for your current class only."],

								validate = validateSpell,

								set = setRange,

								get = getRange,

							},

							hostile = {

								order = 1,

								type = "input",

								name = L["Hostile spell"],

								desc = L["Name of a hostile spell to check range on enemies.|n|nThis is automatically set for your current class only."],

								validate = validateSpell,

								set = setRange,

								get = getRange,

							},

						},

					},

				},

			},

			color = {

				order = 2,

				type = "group",

				name = L["Colors"],

				args = {

					health = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Health"],

						set = setColor,

						get = getColor,

						args = {

							green = {

								order = 1,

								type = "color",

								name = L["High health"],

								desc = L["Health bar color used as the transitional color for 100% -> 50% on players, as well as when your pet is happy."],

								arg = "healthColors.green",

							},

							yellow = {

								order = 2,

								type = "color",

								name = L["Half health"],

								desc = L["Health bar color used as the transitional color for 100% -> 0% on players, as well as when your pet is mildly unhappy."],

								arg = "healthColors.yellow",

							},

							red = {

								order = 3,

								type = "color",

								name = L["Low health"],

								desc = L["Health bar color used as the transitional color for 50% -> 0% on players, as well as when your pet is very unhappy."],

								arg = "healthColors.red",

							},

							friendly = {

								order = 4,

								type = "color",

								name = L["Friendly"],

								desc = L["Health bar color for friendly units."],

								arg = "healthColors.friendly",

							},

							neutral = {

								order = 5,

								type = "color",

								name = L["Neutral"],

								desc = L["Health bar color for neutral units."],

								arg = "healthColors.neutral",

							},

							hostile = {

								order = 6,

								type = "color",

								name = L["Hostile"],

								desc = L["Health bar color for hostile units."],

								arg = "healthColors.hostile",

							},

							static = {

								order = 7,

								type = "color",

								name = L["Static"],

								desc = L["Color to use for health bars that are set to be colored by a static color."],

								arg = "healthColors.static",

							},

							inc = {

								order = 8,

								type = "color",

								name = L["Incoming heal"],

								desc = L["Health bar color to use to show how much healing someone is about to receive."],

								arg = "healthColors.inc",

							},

							enemyUnattack = {

								order = 9,

								type = "color",

								name = L["Unattackable hostile"],

								desc = L["Health bar color to use for hostile units who you cannot attack, used for reaction coloring."],

								hidden = hideAdvancedOption,

								arg = "healthColors.enemyUnattack",

							}

						},

					},

					power = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Power"],

						set = setColor,

						get = getColor,

						args = {

							MANA = {

								order = 0,

								type = "color",

								name = L["Mana"],

								hasAlpha = true,

								width = "half",

								arg = "powerColors.MANA",

							},

							RAGE = {

								order = 1,

								type = "color",

								name = L["Rage"],

								hasAlpha = true,

								width = "half",

								arg = "powerColors.RAGE",

							},

							FOCUS = {

								order = 2,

								type = "color",

								name = L["Focus"],

								hasAlpha = true,

								arg = "powerColors.FOCUS",

								width = "half",

							},

							ENERGY = {

								order = 3,

								type = "color",

								name = L["Energy"],

								hasAlpha = true,

								arg = "powerColors.ENERGY",

								width = "half",

							},

							RUNIC_POWER = {

								order = 6,

								type = "color",

								name = L["Runic Power"],

								hasAlpha = true,

								arg = "powerColors.RUNIC_POWER",

							},

							ECLIPSE_MOON = {

								order = 7,

								type = "color",

								name = L["Eclipse (Moon)"],

								desc = L["Bar coloring for the moon portion of the eclipse bar."],

								hidden = function(info) return select(2, UnitClass("player")) ~= "DRUID" end,

								hasAlpha = true,

								arg = "powerColors.ECLIPSE_MOON",

							},

							ECLIPSE_SUN = {

								order = 8,

								type = "color",

								name = L["Eclipse (Sun)"],

								desc = L["Bar coloring for the moon portion of the eclipse bar."],

								hidden = function(info) return select(2, UnitClass("player")) ~= "DRUID" end,

								hasAlpha = true,

								arg = "powerColors.ECLIPSE_SUN",

							},

							AMMOSLOT = {

								order = 9,

								type = "color",

								name = L["Ammo"],

								hasAlpha = true,

								arg = "powerColors.AMMOSLOT",

								hidden = hideAdvancedOption,

							},

							FUEL = {

								order = 10,

								type = "color",

								name = L["Fuel"],

								hasAlpha = true,

								arg = "powerColors.FUEL",

								hidden = hideAdvancedOption,

							},

							COMBOPOINTS = {

								order = 11,

								type = "color",

								name = L["Combo points"],

								hasAlpha = true,

								arg = "powerColors.COMBOPOINTS",

							},

							HOLYPOWER = {

								order = 12,

								type = "color",

								name = L["Holy Power"],

								hasAlpha = true,

								arg = "powerColors.HOLYPOWER",

								hidden = function(info) return select(2, UnitClass("player")) ~= "PALADIN" end,

							},

							SOULSHARDS = {

								order = 13,

								type = "color",

								name = L["Soul Shards"],

								hasAlpha = true,

								arg = "powerColors.SOULSHARDS",

								hidden = function(info) return select(2, UnitClass("player")) ~= "WARLOCK" end,

							},

						},

					},

					cast = {

						order = 3,

						type = "group",

						inline = true,

						name = L["Cast"],

						set = setColor,

						get = getColor,

						args = {

							cast = {

								order = 0,

								type = "color",

								name = L["Casting"],

								desc = L["Color used when an unit is casting a spell."],

								arg = "castColors.cast",

							},

							channel = {

								order = 1,

								type = "color",

								name = L["Channelling"],

								desc = L["Color used when a cast is a channel."],

								arg = "castColors.channel",

							},

							sep = {

								order = 2,

								type = "description",

								name = "",

								hidden = hideAdvancedOption,

								width = "full",

							},

							finished = {

								order = 3,

								type = "color",

								name = L["Finished cast"],

								desc = L["Color used when a cast is successfully finished."],

								hidden = hideAdvancedOption,

								arg = "castColors.finished",

							},

							interrupted = {

								order = 4,

								type = "color",

								name = L["Cast interrupted"],

								desc = L["Color used when a cast is interrupted either by the caster themselves or by another unit."],

								hidden = hideAdvancedOption,

								arg = "castColors.interrupted",

							},

							uninterruptible = {

								order = 5,

								type = "color",

								name = L["Cast uninterruptible"],

								desc = L["Color used when a cast cannot be interrupted, this is only used for PvE mobs."],

								arg = "castColors.uninterruptible",

							},

						},

					},

					auras = {

						order = 3.5,

						type = "group",

						inline = true,

						name = L["Aura borders"],

						set = setColor,

						get = getColor,

						hidden = hideAdvancedOption,

						args = {

							removableColor = {

								order = 0,

								type = "color",

								name = L["Stealable or Removable"],

								desc = L["Border coloring of stealable or removable auras."],

								arg = "auraColors.removable",

							}

						}

					},

					classColors = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Classes"],

						set = setColor,

						get = getColor,

						args = {}

					},

				},

			},

			profile = LibStub("AceDBOptions-3.0"):GetOptionsTable(ShadowUF.db, true),

			text = {

				type = "group",

				order = 6,

				name = L["Text management"],

				hidden = false,

				args = {

					help = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Help"],

						args = {

							help = {

								order = 0,

								type = "description",

								name = L["You can add additional text with tags enabled using this configuration, note that any additional text added (or removed) effects all units, removing text will reset their settings as well.|n|nKeep in mind, you cannot delete the default text included with the units."],

							},

						},

					},

					add = {

						order = 1,

						name = L["Add new text"],

						inline = true,

						type = "group",

						set = function(info, value) textData[info[#(info)] ] = value end,

						get = function(info, value) return textData[info[#(info)] ] end,

						args = {

							name = {

								order = 0,

								type = "input",

								name = L["Text name"],

								desc = L["Text name that you can use to identify this text from others when configuring."],

							},

							parent = {

								order = 1,

								type = "select",

								name = L["Text parent"],

								desc = L["Where inside the frame the text should be anchored to."],

								values = barModules,

							},

							add = {

								order = 2,

								type = "execute",

								name = L["Add"],

								disabled = function() return not textData.name or textData.name == "" or not textData.parent end,

								func = function(info)

									-- Verify we entered a good name

									textData.name = string.trim(textData.name)

									textData.name = textData.name ~= "" and textData.name or nil

									

									-- Add the new entry

									for _, unit in pairs(ShadowUF.unitList) do

										table.insert(ShadowUF.db.profile.units[unit].text, {enabled = true, name = textData.name or "??", text = "", anchorTo = textData.parent, x = 0, y = 0, anchorPoint = "C", size = 0, width = 0.50})

									end

									

									-- Add it to the GUI

									local id = tostring(#(ShadowUF.db.profile.units.player.text))

									addTextParent.args[id .. ":label"] = addTextLabel

									addTextParent.args[id] = addText

									addTextParent.args[id .. ":sep"] = addTextSep

									options.args.general.args.text.args[textData.parent] = options.args.general.args.text.args[textData.parent] or addTextParent

									

									local parent = string.sub(textData.parent, 2)

									Config.tagWizard[parent] = Config.tagWizard[parent] or Config.parentTable

									Config.tagWizard[parent].args[id] = Config.tagTextTable

									Config.tagWizard[parent].args[id .. ":adv"] = Config.advanceTextTable

									

									quickIDMap[id .. ":adv"] = #(ShadowUF.db.profile.units.player.text)

									

									-- Reset

									textData.name = nil

									textData.parent = nil

									

								end,

							},

						},

					},

				},

			},

			layout = layoutManager,

		},

	}

	

	-- Load text

	for id, text in pairs(ShadowUF.db.profile.units.player.text) do

		addTextParent.args[id .. ":label"] = addTextLabel

		addTextParent.args[tostring(id)] = addText

		addTextParent.args[id .. ":sep"] = addTextSep

		options.args.general.args.text.args[text.anchorTo] = addTextParent

	end

	

	

	Config.classTable = {

		order = 0,

		type = "color",

		name = getName,

		hasAlpha = true,

		width = "half",

		arg = "classColors.$key",

	}

	

	for classToken in pairs(RAID_CLASS_COLORS) do

		options.args.general.args.color.args.classColors.args[classToken] = Config.classTable

	end

	

	options.args.general.args.color.args.classColors.args.PET = Config.classTable

	options.args.general.args.color.args.classColors.args.VEHICLE = Config.classTable

	

	options.args.general.args.profile.order = 4

end



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

-- HIDE BLIZZARD FRAMES CONFIGURATION

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

local function loadHideOptions()

	Config.hideTable = {

		order = function(info) return info[#(info)] == "buffs" and 1 or 2 end,

		type = "toggle",

		name = function(info)

			local key = info[#(info)]

			return L.units[key] and string.format(L["Hide %s frames"], string.lower(L.units[key])) or string.format(L["Hide %s"], key == "cast" and L["player cast bar"] or key == "runes" and L["rune bar"] or key == "buffs" and L["buff frames"] or key == "playerAltPower" and L["player alt. power"])

		end,

		set = function(info, value)

			set(info, value)

			if( value ) then ShadowUF:HideBlizzardFrames() end

		end,

		hidden = false,

		get = get,

		arg = "hidden.$key",

	}

	

	options.args.hideBlizzard = {

		type = "group",

		name = L["Hide Blizzard"],

		desc = getPageDescription,

		args = {

			help = {

				order = 0,

				type = "group",

				name = L["Help"],

				inline = true,

				args = {

					description = {

						type = "description",

						name = L["You will need to do a /console reloadui before a hidden frame becomes visible again.|nPlayer and other unit frames are automatically hidden depending on if you enable the unit in Shadowed Unit Frames."],

						width = "full",

					},

				},

			},

			hide = {

				order = 1,

				type = "group",

				name = L["Frames"],

				inline = true,

				args = {

					buffs = Config.hideTable,

					cast = Config.hideTable,

					runes = Config.hideTable,

					party = Config.hideTable,

                    raid = Config.hideTable,

					player = Config.hideTable,

					pet = Config.hideTable,

					target = Config.hideTable,

					focus = Config.hideTable,

					boss = Config.hideTable,

					arena = Config.hideTable,

					playerAltPower = Config.hideTable,

				},

			},

		}

	}

end



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

-- UNIT CONFIGURATION

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

local function loadUnitOptions()

	-- This makes sure  we don't end up with any messed up positioning due to two different anchors being used

	local function fixPositions(info)

		local unit = info[2]

		local key = info[#(info)]

		

		if( key == "point" or key == "relativePoint" ) then

			ShadowUF.db.profile.positions[unit].anchorPoint = ""

			ShadowUF.db.profile.positions[unit].movedAnchor = nil

		elseif( key == "anchorPoint" ) then

			ShadowUF.db.profile.positions[unit].point = ""

			ShadowUF.db.profile.positions[unit].relativePoint = ""

		end

		

		-- Reset offset if it was a manually positioned frame, and it got anchored

		-- Why 100/-100 you ask? Because anything else requires some sort of logic applied to it

		-- and this means the frames won't directly overlap too which is a nice bonus

		if( key == "anchorTo" ) then

			ShadowUF.db.profile.positions[unit].x = 100

			ShadowUF.db.profile.positions[unit].y = -100

		end

	end

		

	-- Hide raid option in party config

	local function hideRaidOrAdvancedOption(info)

		if( info[2] == "party" and ShadowUF.db.profile.advanced ) then return false end

		

		return info[2] ~= "raid" and info[2] ~= "raidpet" and info[2] ~= "maintank" and info[2] ~= "mainassist"

	end

	

	local function hideRaidOption(info)

		return info[2] ~= "raid" and info[2] ~= "raidpet" and info[2] ~= "maintank" and info[2] ~= "mainassist"

	end

	

	local function hideSplitOrRaidOption(info)

		if( info[2] == "raid" and ShadowUF.db.profile.units.raid.frameSplit ) then

			return true

		end

		

		return hideRaidOption(info) 

	end



	-- Not every option should be changed via global settings

	local function hideSpecialOptions(info)

		local unit = info[2]

		if( unit == "global" or unit == "partypet" ) then

			return true

		end

		

		return hideAdvancedOption(info)

	end

	

	local function checkNumber(info, value)

		return tonumber(value)

	end

	

	local function setPosition(info, value)

		ShadowUF.db.profile.positions[info[2]][info[#(info)]] = value

		fixPositions(info)

		

		if( info[2] == "raid" or info[2] == "raidpet" or info[2] == "maintank" or info[2] == "mainassist" or info[2] == "party" or info[2] == "boss" or info[2] == "arena" ) then

			ShadowUF.Units:ReloadHeader(info[2])

		else

			ShadowUF.Layout:Reload(info[2])

		end

	end

	

	local function getPosition(info)

		return ShadowUF.db.profile.positions[info[2]][info[#(info)]]

	end



	local function setNumber(info, value)

		local unit = info[2]

		local key = info[#(info)]

		local id = unit .. key

		

		-- Apply effective scaling if it's anchored to UIParent

		if( ShadowUF.db.profile.positions[unit].anchorTo == "UIParent" ) then

			value = value * (ShadowUF.db.profile.units[unit].scale * UIParent:GetScale())

		end

		

		setPosition(info, tonumber(value))

	end

	

	local function getString(info)

		local unit = info[2]

		local key = info[#(info)]

		local id = unit .. key

		local coord = getPosition(info)

		

		-- If the frame is created and it's anchored to UIParent, will return the number modified by scale

		if( ShadowUF.db.profile.positions[unit].anchorTo == "UIParent" ) then

			coord = coord / (ShadowUF.db.profile.units[unit].scale * UIParent:GetScale())

		end

				

		-- OCD, most definitely.

		-- Pain to check coord == math.floor(coord) because floats are handled oddly with frames and return 0.99999999999435

		return string.gsub(string.format("%.2f", coord), "%.00$", "")

	end

	

	

	-- TAG WIZARD

	local tagWizard = {}

	Config.tagWizard = tagWizard

	do

		-- Load tag list

		Config.advanceTextTable = {

			order = 1,

			name = function(info) return getVariable(info[2], "text", quickIDMap[info[#(info)]], "name")  end,

			type = "group",

			inline = true,

			hidden = function(info)

				if( not getVariable(info[2], "text", nil, quickIDMap[info[#(info)]]) ) then return true end

				return string.sub(getVariable(info[2], "text", quickIDMap[info[#(info)]], "anchorTo"), 2) ~= info[#(info) - 1]

			end,

			set = function(info, value)

				info.arg = string.format("text.%s.%s", quickIDMap[info[#(info) - 1]], info[#(info)])

				setUnit(info, value)

			end,

			get = function(info)

				info.arg = string.format("text.%s.%s", quickIDMap[info[#(info) - 1]], info[#(info)])

				return getUnit(info)

			end,

			args = {

				anchorPoint = {

					order = 1,

					type = "select",

					name = L["Anchor point"],

					values = {["LC"] = L["Left Center"], ["RT"] = L["Right Top"], ["RB"] = L["Right Bottom"], ["LT"] = L["Left Top"], ["LB"] = L["Left Bottom"], ["RC"] = L["Right Center"],["TRI"] = L["Inside Top Right"], ["TLI"] = L["Inside Top Left"], ["CLI"] = L["Inside Center Left"], ["C"] = L["Inside Center"], ["CRI"] = L["Inside Center Right"], ["TR"] = L["Top Right"], ["TL"] = L["Top Left"], ["BR"] = L["Bottom Right"], ["BL"] = L["Bottom Left"]},

					hidden = hideAdvancedOption,

				},

				sep = {

					order = 2,

					type = "description",

					name = "",

					width = "full",

					hidden = hideAdvancedOption,

				},

				width = {

					order = 3,

					name = L["Width weight"],

					desc = L["How much weight this should use when figuring out the total text width."],

					type = "range",

					min = 0, max = 10, step = 0.1,

					hidden = false,

				},

				size = {

					order = 4,

					name = L["Size"],

					desc = L["Let's you modify the base font size to either make it larger or smaller."],

					type = "range",

					min = -20, max = 20, step = 1, softMin = -5, softMax = 5,

					hidden = false,

				},

				x = {

					order = 5,

					type = "range",

					name = L["X Offset"],

					min = -1000, max = 1000, step = 1, softMin = -100, softMax = 100,

					hidden = false,

				},

				y = {

					order = 6,

					type = "range",

					name = L["Y Offset"],

					min = -1000, max = 1000, step = 1, softMin = -100, softMax = 100,

					hidden = false,

				},

			},

		}

		

		Config.parentTable = {

			order = 0,

			type = "group",

			hidden = false,

			name = function(info) return getName(info) or string.sub(info[#(info)], 1) end,

			hidden = function(info) return not getVariable(info[2], info[#(info)], nil, "enabled") end,

			args = {}

		}

		

		local function hideBlacklistedTag(info)

			local unit = info[2]

			local tag = info[#(info)]

			

			if( unit == "global" ) then

				for unit in pairs(modifyUnits) do

					if( ShadowUF.Tags.unitRestrictions[tag] == unit ) then

						return false

					end

				end

			end

			

			if( ShadowUF.Tags.unitRestrictions[tag] and ShadowUF.Tags.unitRestrictions[tag] ~= unit ) then

				return true

			end



			return false

		end

		

		local function hideBlacklistedGroup(info)

			local unit = info[2]

			local tagGroup = info[#(info)]

			if( unit ~= "global" ) then

				if( ShadowUF.Tags.unitBlacklist[tagGroup] and string.match(unit, ShadowUF.Tags.unitBlacklist[tagGroup]) ) then

					return true

				end

			else

				-- If the only units that are in the global configuration have the tag filtered, then don't bother showing it

				for unit in pairs(modifyUnits) do

					if( not ShadowUF.Tags.unitBlacklist[tagGroup] or not string.match(unit, ShadowUF.Tags.unitBlacklist[tagGroup]) ) then

						return false

					end

				end

			end

			

			return false

		end

		

		local savedTagTexts = {}

		local function selectTag(info, value)

			local unit = info[2]

			local id = tonumber(info[#(info) - 2])

			local tag = info[#(info)]

			local text = getVariable(unit, "text", id, "text")

			local savedText



			if( value ) then

				if( unit == "global" ) then

					table.wipe(savedTagTexts)

					

					-- Set special tag texts based on the unit, so targettarget won't get a tag that will cause errors

					local tagGroup = ShadowUF.Tags.defaultCategories[tag]

					for unit in pairs(modifyUnits) do

						savedTagTexts[unit] = getVariable(unit, "text", id, "text")

						if( not ShadowUF.Tags.unitBlacklist[tagGroup] or not string.match(unit, ShadowUF.Tags.unitBlacklist[tagGroup]) ) then

							if( not ShadowUF.Tags.unitRestrictions[tag] or ShadowUF.Tags.unitRestrictions[tag] == unit ) then

								if( text == "" ) then

									savedTagTexts[unit] = string.format("[%s]", tag)

								else

									savedTagTexts[unit] = string.format("%s[( )%s]", savedTagTexts[unit], tag)

								end

								

								savedTagTexts.global = savedTagTexts[unit]

							end

						end

					end

				else

					if( text == "" ) then

						text = string.format("[%s]", tag)

					else

						text = string.format("%s[( )%s]", text, tag)

					end

				end

			-- Removing a tag from global config, need to make sure we can do it

			-- Hack, clean up later

			elseif( unit == "global" ) then

				table.wipe(savedTagTexts)

				for unit in pairs(modifyUnits) do

					if( not ShadowUF.Tags.unitBlacklist[tagGroup] or not string.match(unit, ShadowUF.Tags.unitBlacklist[tagGroup]) ) then

						if( not ShadowUF.Tags.unitRestrictions[tag] or ShadowUF.Tags.unitRestrictions[tag] == unit ) then

							local text = getVariable(unit, "text", id, "text")

							for matchedTag in string.gmatch(text, "%[(.-)%]") do

								local safeTag = "[" .. matchedTag .. "]"

								if( string.match(safeTag, "%[" .. tag .. "%]") or string.match(safeTag, "%)" .. tag .. "%]") or string.match(safeTag, "%[" .. tag .. "%(") or string.match(safeTag, "%)" .. tag .. "%(") ) then

									text = string.gsub(text, "%[" .. string.gsub(string.gsub(matchedTag, "%)", "%%)"), "%(", "%%(") .. "%]", "")

									text = string.gsub(text, "  ", "")

									text = string.trim(text)

									break

								end

							end

							

							savedTagTexts[unit] = text

							savedTagTexts.global = text

						end

					end

				end

				

			-- Removing a tag from a single unit, super easy :<

			else

				-- Ugly, but it works

				for matchedTag in string.gmatch(text, "%[(.-)%]") do

					local safeTag = "[" .. matchedTag .. "]"

					if( string.match(safeTag, "%[" .. tag .. "%]") or string.match(safeTag, "%)" .. tag .. "%]") or string.match(safeTag, "%[" .. tag .. "%(") or string.match(safeTag, "%)" .. tag .. "%(") ) then

						text = string.gsub(text, "%[" .. string.gsub(string.gsub(matchedTag, "%)", "%%)"), "%(", "%%(") .. "%]", "")

						text = string.gsub(text, "  ", "")

						text = string.trim(text)

						break

					end

				end

			end

			

			if( unit == "global" ) then

				for unit in pairs(modifyUnits) do

					if( savedTagTexts[unit] ) then

						setVariable(unit, "text", id, "text", savedTagTexts[unit])

					end

				end



				setVariable("global", "text", id, "text", savedTagTexts.global)

			else

				setVariable(unit, "text", id, "text", text)

			end

		end

		

		local function getTag(info)

			local text = getVariable(info[2], "text", tonumber(info[#(info) - 2]), "text")

			local tag = info[#(info)]

			

			-- FUN WITH PATTERN MATCHING

			if( string.match(text, "%[" .. tag .. "%]") or string.match(text, "%)" .. tag .. "%]") or string.match(text, "%[" .. tag .. "%(") or string.match(text, "%)" .. tag .. "%(") ) then

				return true

			end

			

			return false

		end

		

		Config.tagTextTable = {

			type = "group",

			name = function(info) return getVariable(info[2], "text", nil, tonumber(info[#(info)])) and getVariable(info[2], "text", tonumber(info[#(info)]), "name") or "" end,

			hidden = function(info)

				if( not getVariable(info[2], "text", nil, tonumber(info[#(info)])) ) then return true end

				return string.sub(getVariable(info[2], "text", tonumber(info[#(info)]), "anchorTo"), 2) ~= info[#(info) - 1] end,

			set = false,

			get = false,

			args = {

				text = {

					order = 0,

					type = "input",

					name = L["Text"],

					width = "full",

					hidden = false,

					set = function(info, value) setUnit(info, string.gsub(value, "||", "|")) end,

					get = function(info) return string.gsub(getUnit(info), "|", "||") end,

					arg = "text.$parent.text",

				},

			},

		}

		

		

		local function getCategoryOrder(info)

			return info[#(info)] == "health" and 1 or info[#(info)] == "power" and 2 or info[#(info)] == "misc" and 3 or 4

		end

		

		for _, cat in pairs(ShadowUF.Tags.defaultCategories) do

			Config.tagTextTable.args[cat] = Config.tagTextTable.args[cat] or {

				order = getCategoryOrder,

				type = "group",

				inline = true,

				name = getName,

				hidden = hideBlacklistedGroup,

				set = selectTag,

				get = getTag,

				args = {},

			}			

		end



		Config.tagTable = {

			order = 0,

			type = "toggle",

			hidden = hideBlacklistedTag,

			name = getTagName, 

			desc = getTagHelp,

		}

				

		local tagList = {}

		for tag in pairs(ShadowUF.Tags.defaultTags) do

			local category = ShadowUF.Tags.defaultCategories[tag] or "misc"

			Config.tagTextTable.args[category].args[tag] = Config.tagTable

		end

			

		for tag, data in pairs(ShadowUF.db.profile.tags) do

			local category = data.category or "misc"

			Config.tagTextTable.args[category].args[tag] = Config.tagTable

		end

		

		local parentList = {}

		for id, text in pairs(ShadowUF.db.profile.units.player.text) do

			parentList[text.anchorTo] = parentList[text.anchorTo] or {}

			parentList[text.anchorTo][id] = text

		end

		

		local nagityNagNagTable = {

			order = 0,

			type = "group",

			name = L["Help"],

			inline = true,

			hidden = false,

			args = {

				help = {

					order = 0,

					type = "description",

					name = L["Selecting a tag text from the left panel to change tags. Truncating width, sizing, and offsets can be done in the current panel."],

				},

			},

		}

	

		for parent, list in pairs(parentList) do

			parent = string.sub(parent, 2)

			tagWizard[parent] = Config.parentTable

			Config.parentTable.args.help = nagityNagNagTable

			

			for id in pairs(list) do

				tagWizard[parent].args[tostring(id)] = Config.tagTextTable

				tagWizard[parent].args[tostring(id) .. ":adv"] = Config.advanceTextTable

				

				quickIDMap[tostring(id) .. ":adv"] = id

			end

		end

	end

		

	local function disableAnchoredTo(info)

		local auras = getVariable(info[2], "auras", nil, info[#(info) - 1])

		

		return auras.anchorOn or not auras.enabled

	end

	

	local function disableSameAnchor(info)

		local buffs = getVariable(info[2], "auras", nil, "buffs")

		local debuffs = getVariable(info[2], "auras", nil, "debuffs")

		local anchor = buffs.enabled and buffs.prioritize and "buffs" or "debuffs"

		

		if( not getVariable(info[2], "auras", info[#(info) - 1], "enabled") ) then

			return true

		end

		

		if( ( info[#(info)] == "x" or info[#(info)] == "y" ) and ( info[#(info) - 1] == "buffs" and buffs.anchorOn or info[#(info) - 1] == "debuffs" and debuffs.anchorOn ) ) then

			return true

		end

		

		if( anchor == info[#(info) - 1] or buffs.anchorOn or debuffs.anchorOn ) then

			return false

		end	

		

		return buffs.anchorPoint == debuffs.anchorPoint

	end

	

	local defaultAuraList = {["BL"] = L["Bottom"], ["TL"] = L["Top"], ["LT"] = L["Left"], ["RT"] = L["Right"]}

	local advancedAuraList = {["BL"] = L["Bottom Left"], ["BR"] = L["Bottom Right"], ["TL"] = L["Top Left"], ["TR"] = L["Top Right"], ["RT"] = L["Right Top"], ["RB"] = L["Right Bottom"], ["LT"] = L["Left Top"], ["LB"] = L["Left Bottom"]}

	local function getAuraAnchors()

		return ShadowUF.db.profile.advanced and advancedAuraList or defaultAuraList

	end

	

	local function hideStealable(info)

		if( not ShadowUF.db.profile.advanced ) then return true end

		if( info[2] == "player" or info[2] == "pet" or info[#(info) - 1] == "debuffs" ) then return true end

		

		return false

	end

	

	Config.auraTable = {

		type = "group",

		inline = true,

		hidden = false,

		name = function(info) return info[#(info)] == "buffs" and L["Buffs"] or L["Debuffs"] end,

		order = function(info) return info[#(info)] == "buffs" and 1 or 2 end,

		disabled = function(info) return not getVariable(info[2], "auras", info[#(info) - 1], "enabled") end,

		args = {

			enabled = {

				order = 1,

				type = "toggle",

				name = function(info) if( info[#(info) - 1] == "buffs" ) then return L["Enable buffs"] end return L["Enable debuffs"] end,

				disabled = false,

				arg = "auras.$parent.enabled",

			},

			anchorOn = {

				order = 2,

				type = "toggle",

				name = function(info) return info[#(info) - 1] == "buffs" and L["Anchor to debuffs"] or L["Anchor to buffs"] end,

				desc = L["Allows you to anchor the aura group to another, you can then choose where it will be anchored using the position.|n|nUse this if you want to duplicate the default ui style where buffs and debuffs are separate groups."],

				set = function(info, value)

					setVariable(info[2], "auras", info[#(info) - 1] == "buffs" and "debuffs" or "buffs", "anchorOn", false)

					setUnit(info, value)

				end,

				arg = "auras.$parent.anchorOn",

			},

			prioritize = {

				order = 2.25,

				type = "toggle",

				name = L["Prioritize buffs"],

				desc = L["Show buffs before debuffs when sharing the same anchor point."],

				hidden = function(info) return info[#(info) - 1] == "debuffs" end,

				disabled = function(info) 

					if( not getVariable(info[2], "auras", info[#(info) - 1], "enabled") ) then return true end

					

					local buffs = getVariable(info[2], "auras", nil, "buffs")

					local debuffs = getVariable(info[2], "auras", nil, "debuffs")

					

					return buffs.anchorOn or debuffs.anchorOn or buffs.anchorPoint ~= debuffs.anchorPoint

				end,

				arg = "auras.$parent.prioritize",

			},

			sep2 = {

				order = 6,

				type = "description",

				name = "",

				width = "full",

			},

			enlargeStealable = {

				order = 6.5,

				type = "toggle",

				name = L["Enlarge removable auras"],

				desc = L["If you can Spellsteal or remove an aura, then it will be shown scaled using the scaled aura size option."],

				arg = "auras.$parent.enlargeStealable",

				hidden = hideStealable,

			},

			player = {

				order = 7,

				type = "toggle",

				name = L["Show your auras only"],

				desc = L["Filter out any auras that you did not cast yourself."],

				arg = "auras.$parent.player",

			},

			raid = {

				order = 8,

				type = "toggle",

				name = function(info) return info[#(info) - 1] == "buffs" and L["Show castable on other auras only"] or L["Show curable only"] end,

				desc = function(info) return info[#(info) - 1] == "buffs" and L["Filter out any auras that you cannot cast on another player, or yourself."] or L["Filter out any aura that you cannot cure."] end,

				width = "double",

				arg = "auras.$parent.raid",

				hidden = function(info) return not hideStealable(info) end,

			},

			raid2 = {

				order = 8,

				type = "toggle",

				name = function(info) return info[#(info) - 1] == "buffs" and L["Show castable on other auras only"] or L["Show curable only"] end,

				desc = function(info) return info[#(info) - 1] == "buffs" and L["Filter out any auras that you cannot cast on another player, or yourself."] or L["Filter out any aura that you cannot cure."] end,

				arg = "auras.$parent.raid",

				hidden = hideStealable,

			},

			sep3 = {

				order = 9,

				type = "description",

				name = "",

				width = "full",

			},

			selfTimers = {

				order = 9.5,

				type = "toggle",

				name = L["Timers for self auras only"],

				desc = L["Hides the cooldown ring for any auras that you did not cast."],

				hidden = hideAdvancedOption,

				arg = "auras.$parent.selfTimers",

			},

			enlargeSelf = {

				order = 10,

				type = "toggle",

				name = L["Enlarge your auras"],

				desc = L["If you casted the aura, then the buff icon will be increased in size to make it more visible."],

				arg = "auras.$parent.enlargeSelf",

			},

			selfScale = {

				order = 11,

				type = "range",

				name = L["Scaled aura size"],

				desc = L["Scale for auras that you casted or can Spellsteal, any number above 100% is bigger than default, any number below 100% is smaller than default."],

				min = 1, max = 3, step = 0.10,

				isPercent = true,

				disabled = function(info) return not getVariable(info[2], "auras", info[#(info) - 1], "enlargeSelf") end,

				hidden = hideAdvancedOption,

				arg = "auras.$parent.selfScale",

			},

			selfTimersDouble = {

				order = 11,

				type = "toggle",

				name = L["Timers for self auras only"],

				desc = L["Hides the cooldown ring for any auras that you did not cast."],

				hidden = hideBasicOption,

				arg = "auras.$parent.selfTimers",

				width = "double",

			},

			sep4 = {

				order = 12,

				type = "description",

				name = "",

				width = "full",

			},

			perRow = {

				order = 13,

				type = "range",

				name = function(info)

					local anchorPoint = getVariable(info[2], "auras", info[#(info) - 1], "anchorPoint")

					if( ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "LEFT" or ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "RIGHT" ) then

						return L["Per column"]

					end

					

					return L["Per row"]

				end,

				desc = L["How many auras to show in a single row."],

				min = 1, max = 100, step = 1, softMin = 1, softMax = 50,

				disabled = disableSameAnchor,

				arg = "auras.$parent.perRow",

			},

			maxRows = {

				order = 14,

				type = "range",

				name = L["Max rows"],

				desc = L["How many rows total should be used, rows will be however long the per row value is set at."],

				min = 1, max = 10, step = 1, softMin = 1, softMax = 5,

				disabled = disableSameAnchor,

				hidden = function(info)

					local anchorPoint = getVariable(info[2], "auras", info[#(info) - 1], "anchorPoint")

					if( ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "LEFT" or ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "RIGHT" ) then

						return true

					end

					

					return false

				end,

				arg = "auras.$parent.maxRows",

			},

			maxColumns = {

				order = 14,

				type = "range",

				name = L["Max columns"],

				desc = L["How many auras per a column for example, entering two her will create two rows that are filled up to whatever per row is set as."],

				min = 1, max = 100, step = 1, softMin = 1, softMax = 50,

				hidden = function(info)

					local anchorPoint = getVariable(info[2], "auras", info[#(info) - 1], "anchorPoint")

					if( ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "LEFT" or ShadowUF.Layout:GetColumnGrowth(anchorPoint) == "RIGHT" ) then

						return false

					end

					

					return true

				end,

				disabled = disableSameAnchor,

				arg = "auras.$parent.maxRows",

			},

			size = {

				order = 15,

				type = "range",

				name = L["Size"],

				min = 1, max = 30, step = 1,

				arg = "auras.$parent.size",

			},

			sep5 = {

				order = 16,

				type = "description",

				name = "",

				width = "full",

			},

			anchorPoint = {

				order = 17,

				type = "select",

				name = L["Position"],

				desc = L["How you want this aura to be anchored to the unit frame."],

				values = getAuraAnchors,

				disabled = disableAnchoredTo,

				arg = "auras.$parent.anchorPoint",

			},

			x = {

				order = 18,

				type = "range",

				name = L["X Offset"],

				min = -1000, max = 1000, step = 1, softMin = -100, softMax = 100,

				disabled = disableSameAnchor,

				hidden = hideAdvancedOption,

				arg = "auras.$parent.x",

			},

			y = {

				order = 19,

				type = "range",

				name = L["Y Offset"],

				min = -1000, max = 1000, step = 1, softMin = -100, softMax = 100,

				disabled = disableSameAnchor,

				hidden = hideAdvancedOption,

				arg = "auras.$parent.y",

			},

		},

	}

	

	local function hideBarOption(info)

		local module = info[#(info) - 1]

		if( ShadowUF.modules[module].moduleHasBar or getVariable(info[2], module, nil, "isBar") ) then

			return false

		end

		

		return true

	end

	

	local function disableIfCastName(info)

		return not getVariable(info[2], "castBar", "name", "enabled")

	end

	

	

	Config.barTable = {

		order = getModuleOrder,

		name = getName,

		type = "group",

		inline = true,

		hidden = function(info) return hideRestrictedOption(info) or not getVariable(info[2], info[#(info)], nil, "enabled") end,

		args = {

			enableBar = {

				order = 1,

				type = "toggle",

				name = L["Show as bar"],

				desc = L["Turns this widget into a bar that can be resized and ordered just like health and power bars."],

				hidden = function(info) return ShadowUF.modules[info[#(info) - 1]].moduleHasBar end,

				arg = "$parent.isBar",

				width = "full",

			},

			background = {

				order = 1.5,

				type = "toggle",

				name = L["Show background"],

				desc = L["Show a background behind the bars with the same texture/color but faded out."],

				hidden = hideBarOption,

				arg = "$parent.background",

			},

			sep2 = {order = 1.75, type = "description", name = "", hidden = function(info)

				local moduleKey = info[#(info) - 1]

				return ( moduleKey ~= "healthBar" and moduleKey ~= "powerBar" and moduleKey ~= "druidBar" ) or not ShadowUF.db.profile.advanced

			end},

			invert = {

				order = 2,

				type = "toggle",

				name = L["Invert colors"],

				desc = L["Flips coloring so the bar color is shown as the background color and the background as the bar"],

				hidden = function(info) return ( info[#(info) - 1] ~= "healthBar"  and info[#(info) - 1] ~= "powerBar" and info[#(info) - 1] ~= "druidBar" ) or not ShadowUF.db.profile.advanced end,

				arg = "$parent.invert",

			},

			order = {

				order = 4,

				type = "range",

				name = L["Order"],

				min = 0, max = 100, step = 5,

				hidden = hideBarOption,

				arg = "$parent.order",

			},

			height = {

				order = 5,

				type = "range",

				name = L["Height"],

				desc = L["How much of the frames total height this bar should get, this is a weighted value, the higher it is the more it gets."],

				min = 0, max = 10, step = 0.1,

				hidden = hideBarOption,

				arg = "$parent.height",

			},

		},

	}

	

	Config.indicatorTable = {

		order = 0,

		name = function(info)

			if( info[#(info)] == "status" and info[2] == "player" ) then

				return L["Combat/resting status"]

			end

			

			return getName(info)

		end,

		desc = function(info) return INDICATOR_DESC[info[#(info)]] end,

		type = "group",

		hidden = hideRestrictedOption,

		args = {

			enabled = {

				order = 0,

				type = "toggle",

				name = L["Enable indicator"],

				hidden = false,

				arg = "indicators.$parent.enabled",

			},

			sep1 = {

				order = 1,

				type = "description",

				name = "",

				width = "full",

				hidden = function() return not ShadowUF.db.profile.advanced end,

			},

			anchorPoint = {

				order = 2,

				type = "select",

				name = L["Anchor point"],

				values = positionList,

				hidden = false,

				arg = "indicators.$parent.anchorPoint",

			},

			size = {

				order = 4,

				type = "range",

				name = L["Size"],

				min = 1, max = 40, step = 1,

				hidden = hideAdvancedOption,

				arg = "indicators.$parent.size",

			},

			x = {

				order = 5,

				type = "range",

				name = L["X Offset"],

				min = -100, max = 100, step = 1, softMin = -50, softMax = 50,

				hidden = false,

				arg = "indicators.$parent.x",

			},

			y = {

				order = 6,

				type = "range",

				name = L["Y Offset"],

				min = -100, max = 100, step = 1, softMin = -50, softMax = 50,

				hidden = false,

				arg = "indicators.$parent.y",

			},

		},

	}

	

	Config.unitTable = {

		type = "group",

		childGroups = "tab",

		order = getUnitOrder,

		name = getName,

		hidden = isUnitDisabled,

		args = {

			general = {

				order = 1,

				name = L["General"],

				type = "group",

				hidden = isModifiersSet,

				set = setUnit,

				get = getUnit,

				args = {

					vehicle = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Vehicles"],

						hidden = function(info) return info[2] ~= "player" and info[2] ~= "party" or not ShadowUF.db.profile.advanced end,

						args = {

							disable = {

								order = 0,

								type = "toggle",

								name = L["Disable vehicle swap"],

								desc = L["Disables the unit frame from turning into a vehicle when the player enters one."],

								set = function(info, value)

									setUnit(info, value)

									local unit = info[2]

									if( unit == "player" ) then

										if( ShadowUF.Units.unitFrames.pet ) then

											ShadowUF.Units.unitFrames.pet:SetAttribute("disableVehicleSwap", ShadowUF.db.profile.units[unit].disableVehicle)

										end

										

										if( ShadowUF.Units.unitFrames.player ) then

											ShadowUF.Units:CheckVehicleStatus(ShadowUF.Units.unitFrames.player)

										end

									elseif( unit == "party" ) then

										for frame in pairs(ShadowUF.Units.unitFrames) do

											if( frame.unitType == "partypet" ) then

												frame:SetAttribute("disableVehicleSwap", ShadowUF.db.profile.units[unit].disableVehicle)

											elseif( frame.unitType == "party" ) then

												ShadowUF.Units:CheckVehicleStatus(frame)

											end

										end

									end

								end,

								arg = "disableVehicle",

							},

						},

					},

					portrait = {

						order = 2,

						type = "group",

						inline = true,

						hidden = false,

						name = L["Portrait"],

						args = {

							portrait = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Portrait"]),

								arg = "portrait.enabled",

							},

							portraitType = {

								order = 1,

								type = "select",

								name = L["Portrait type"],

								values = {["class"] = L["Class icon"], ["2D"] = L["2D"], ["3D"] = L["3D"]},

								arg = "portrait.type",

							},

							alignment = {

								order = 2,

								type = "select",

								name = L["Position"],

								values = {["LEFT"] = L["Left"], ["RIGHT"] = L["Right"]},

								arg = "portrait.alignment",

							},

						},

					},

					fader = {

						order = 3,

						type = "group",

						inline = true,

						name = L["Combat fader"],

						hidden = hideRestrictedOption,

						args = {

							fader = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Combat fader"]),

								desc = L["Combat fader will fade out all your frames while they are inactive and fade them back in once you are in combat or active."],

								hidden = false,

								arg = "fader.enabled",

							},

							combatAlpha = {

								order = 1,

								type = "range",

								name = L["Combat alpha"],

								desc = L["Frame alpha while this unit is in combat."],

								min = 0, max = 1.0, step = 0.1,

								arg = "fader.combatAlpha",

								hidden = false,

								isPercent = true,

							},

							inactiveAlpha = {

								order = 2,

								type = "range",

								name = L["Inactive alpha"],

								desc = L["Frame alpha when you are out of combat while having no target and 100% mana or energy."],

								min = 0, max = 1.0, step = 0.1,

								arg = "fader.inactiveAlpha",

								hidden = false,

								isPercent = true,

							},

						}

					},

					range = {

						order = 3,

						type = "group",

						inline = true,

						name = L["Range indicator"],

						hidden = hideRestrictedOption,

						args = {

							fader = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Range indicator"]),

								desc = L["Fades out the unit frames of people who are not within range of you."],

								arg = "range.enabled",

								hidden = false,

							},

							inAlpha = {

								order = 1,

								type = "range",

								name = L["In range alpha"],

								desc = L["Frame alpha while this unit is in combat."],

								min = 0, max = 1.0, step = 0.05,

								arg = "range.inAlpha",

								hidden = false,

								isPercent = true,

							},

							oorAlpha = {

								order = 2,

								type = "range",

								name = L["Out of range alpha"],

								min = 0, max = 1.0, step = 0.05,

								arg = "range.oorAlpha",

								hidden = false,

								isPercent = true,

							},

						}

					},

					highlight = {

						order = 3.5,

						type = "group",

						inline = true,

						name = L["Border highlighting"],

						hidden = hideRestrictedOption,

						args = {

							mouseover = {

								order = 3,

								type = "toggle",

								name = L["On mouseover"],

								desc = L["Highlight units when you mouse over them."],

								arg = "highlight.mouseover",

								hidden = false,

							},

							target = { -- hypehuman

								order = 4,

								type = "toggle",

								name = L["For target"], -- hypehuman

								desc = L["Highlight units that you are targeting."], -- hypehuman

								arg = "highlight.target", -- hypehuman

								hidden = function(info) return info[2] == "target" end, -- hypehuman

							},

							focus = { -- hypehuman

								order = 4.5, -- hypehuman

								type = "toggle", -- hypehuman

								name = L["For focus"], -- hypehuman

								desc = L["Highlight units that you have focused."], -- hypehuman

								arg = "highlight.focus", -- hypehuman

								hidden = function(info) return info[2] == "focus" end, -- hypehuman

							},

							aggro = {

								order = 5,

								type = "toggle",

								name = L["On aggro"],

								desc = L["Highlight units that have aggro on any mob."],

								arg = "highlight.aggro",

								hidden = function(info) return info[2] == "arena" or info[2] == "arenapet" or ShadowUF.fakeUnits[info[2]] end,

							},

							debuff = {

								order = 6,

								type = "toggle",

								name = L["On curable debuff"],

								desc = L["Highlight units that are debuffed with something you can cure."],

								arg = "highlight.debuff",

								hidden = function(info) return string.match(info[2], "^arena") or string.match(info[2], "^boss") end,

							},

							alpha = {

								order = 7,

								type = "range",

								name = L["Border alpha"],

								min = 0, max = 1, step = 0.05,

								isPercent = true,

								hidden = false,

								arg = "highlight.alpha",

							},

							size = {

								order = 8,

								type = "range",

								name = L["Border thickness"],

								min = 0, max = 50, step = 1,

								arg = "highlight.size",

								hidden = false,

							},

						},

					},

					-- SOUL SHARDS

					barSouls = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Soul Shards"],

						hidden = function(info) return playerClass ~= "WARLOCK" or not getVariable(info[2], "soulShards", nil, "isBar") or not getVariable(info[2], nil, nil, "soulShards") end,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Soul Shards"]),

								hidden = false,

								arg = "soulShards.enabled",

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["LEFT"] = L["Left"], ["RIGHT"] = L["Right"]},

								hidden = false,

								arg = "soulShards.growth",

							},

							showAlways = {

								order = 3,

								type = "toggle",

								name = L["Don't hide when empty"],

								hidden = false,

								arg = "soulShards.showAlways",

							},

						},

					},

					soulShards = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Soul Shards"],

						hidden = function(info) if( info[2] == "global" or getVariable(info[2], "soulShards", nil, "isBar") ) then return true end return hideRestrictedOption(info) end,

						args = {

							enabled = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Soul Shards"]),

								hidden = false,

								arg = "soulShards.enabled",

							},

							sep1 = {

								order = 1,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["UP"] = L["Up"], ["LEFT"] = L["Left"], ["RIGHT"] = L["Right"], ["DOWN"] = L["Down"]},

								hidden = false,

								arg = "soulShards.growth",

							},

							size = {

								order = 2,

								type = "range",

								name = L["Size"],

								min = 0, max = 50, step = 1, softMin = 0, softMax = 20,

								hidden = hideAdvancedOption,

								arg = "soulShards.size",

							},

							spacing = {

								order = 3,

								type = "range",

								name = L["Spacing"],

								min = -30, max = 30, step = 1, softMin = -15, softMax = 15,

								hidden = hideAdvancedOption,

								arg = "soulShards.spacing",

							},

							sep2 = {

								order = 4,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							anchorPoint = {

								order = 5,

								type = "select",

								name = L["Anchor point"],

								values = positionList,

								hidden = false,

								arg = "soulShards.anchorPoint",

							},

							x = {

								order = 6,

								type = "range",

								name = L["X Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "soulShards.x",

							},

							y = {

								order = 7,

								type = "range",

								name = L["Y Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "soulShards.y",

							},

						},

					},

					-- HOLY POWER

					barHolyPower = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Holy Power"],

						hidden = function(info) return playerClass ~= "PALADIN" or not getVariable(info[2], "soulShards", nil, "isBar") or not getVariable(info[2], nil, nil, "soulShards") end,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Holy Power"]),

								hidden = false,

								arg = "holyPower.enabled",

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["LEFT"] = L["Left"], ["RIGHT"] = L["Right"]},

								hidden = false,

								arg = "holyPower.growth",

							},

							showAlways = {

								order = 3,

								type = "toggle",

								name = L["Don't hide when empty"],

								hidden = false,

								arg = "holyPower.showAlways",

							},

						},

					},

					holyPower = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Holy Power"],

						hidden = function(info) if( info[2] == "global" or getVariable(info[2], "holyPower", nil, "isBar") ) then return true end return hideRestrictedOption(info) end,

						args = {

							enabled = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Holy Power"]),

								hidden = false,

								arg = "holyPower.enabled",

							},

							sep1 = {

								order = 1,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["UP"] = L["Up"], ["LEFT"] = L["Left"], ["RIGHT"] = L["Right"], ["DOWN"] = L["Down"]},

								hidden = false,

								arg = "holyPower.growth",

							},

							size = {

								order = 2,

								type = "range",

								name = L["Size"],

								min = 0, max = 50, step = 1, softMin = 0, softMax = 20,

								hidden = hideAdvancedOption,

								arg = "holyPower.size",

							},

							spacing = {

								order = 3,

								type = "range",

								name = L["Spacing"],

								min = -30, max = 30, step = 1, softMin = -15, softMax = 15,

								hidden = hideAdvancedOption,

								arg = "holyPower.spacing",

							},

							sep2 = {

								order = 4,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							anchorPoint = {

								order = 5,

								type = "select",

								name = L["Anchor point"],

								values = positionList,

								hidden = false,

								arg = "holyPower.anchorPoint",

							},

							x = {

								order = 6,

								type = "range",

								name = L["X Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "holyPower.x",

							},

							y = {

								order = 7,

								type = "range",

								name = L["Y Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "holyPower.y",

							},

						},

					},

					-- COMBO POINTS

					barComboPoints = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Combo points"],

						hidden = function(info) return not getVariable(info[2], "comboPoints", nil, "isBar") or not getVariable(info[2], nil, nil, "comboPoints") end,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Combo points"]),

								hidden = false,

								arg = "comboPoints.enabled",

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["LEFT"] = L["Left"], ["RIGHT"] = L["Right"]},

								hidden = false,

								arg = "comboPoints.growth",

							},

							showAlways = {

								order = 3,

								type = "toggle",

								name = L["Don't hide when empty"],

								hidden = false,

								arg = "comboPoints.showAlways",

							},

						},

					},

					comboPoints = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Combo points"],

						hidden = function(info) if( info[2] == "global" or getVariable(info[2], "comboPoints", nil, "isBar") ) then return true end return hideRestrictedOption(info) end,

						args = {

							enabled = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Combo points"]),

								hidden = false,

								arg = "comboPoints.enabled",

							},

							sep1 = {

								order = 1,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							growth = {

								order = 2,

								type = "select",

								name = L["Growth"],

								values = {["UP"] = L["Up"], ["LEFT"] = L["Left"], ["RIGHT"] = L["Right"], ["DOWN"] = L["Down"]},

								hidden = false,

								arg = "comboPoints.growth",

							},

							size = {

								order = 2,

								type = "range",

								name = L["Size"],

								min = 0, max = 50, step = 1, softMin = 0, softMax = 20,

								hidden = hideAdvancedOption,

								arg = "comboPoints.size",

							},

							spacing = {

								order = 3,

								type = "range",

								name = L["Spacing"],

								min = -30, max = 30, step = 1, softMin = -15, softMax = 15,

								hidden = hideAdvancedOption,

								arg = "comboPoints.spacing",

							},

							sep2 = {

								order = 4,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							anchorPoint = {

								order = 5,

								type = "select",

								name = L["Anchor point"],

								values = positionList,

								hidden = false,

								arg = "comboPoints.anchorPoint",

							},

							x = {

								order = 6,

								type = "range",

								name = L["X Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "comboPoints.x",

							},

							y = {

								order = 7,

								type = "range",

								name = L["Y Offset"],

								min = -30, max = 30, step = 1,

								hidden = false,

								arg = "comboPoints.y",

							},

						},

					},

					combatText = {

						order = 5,

						type = "group",

						inline = true,

						name = L["Combat text"],

						hidden = hideRestrictedOption,

						args = {

							combatText = {

								order = 0,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Combat text"]),

								desc = L["Shows combat feedback, last healing the unit received, last hit did it miss, resist, dodged and so on."],

								arg = "combatText.enabled",

								hidden = false,

							},

							sep = {

								order = 1,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							anchorPoint = {

								order = 3,

								type = "select",

								name = L["Anchor point"],

								values = positionList,

								arg = "combatText.anchorPoint",

								hidden = hideAdvancedOption,

							},

							x = {

								order = 4,

								type = "range",

								name = L["X Offset"],

								min = -50, max = 50, step = 1,

								arg = "combatText.x",

								hidden = hideAdvancedOption,

							},

							y = {

								order = 5,

								type = "range",

								name = L["Y Offset"],

								min = -50, max = 50, step = 1,

								arg = "combatText.y",

								hidden = hideAdvancedOption,

							},

						},

					},

				},

			},

			attributes = {

				order = 1.5,

				type = "group",

				name = function(info) return L.units[info[#(info) - 1]] end,

				hidden = function(info)

					local unit = info[#(info) - 1]

					return unit ~= "raid" and unit ~= "raidpet" and unit ~= "party" and unit ~= "mainassist" and unit ~= "maintank" and unit ~= "boss" and unit ~= "arena"

				end,

				set = function(info, value)

					setUnit(info, value)



					ShadowUF.Units:ReloadHeader(info[2])

					ShadowUF.modules.movers:Update()

				end,

				get = getUnit,

				args = {

					show = {

						order = 0.5,

						type = "group",

						inline = true,

						name = L["Visibility"],

						hidden = function(info) return info[2] ~= "party" and info[2] ~= "raid" end,

						args = {

							showPlayer = {

								order = 0,

								type = "toggle",

								name = L["Show player in party"],

								desc = L["The player frame will not be hidden regardless, you will have to manually disable it either entirely or per zone type."],

								hidden = function(info) return info[2] ~= "party" end,

								arg = "showPlayer",

							},

							hideSemiRaidParty = {

								order = 1,

								type = "toggle",

								name = L["Hide in >5-man raids"],

								desc = L["Party frames are hidden while in a raid group with more than 5 people inside."],

								hidden = function(info) return info[2] ~= "party" end,

								set = function(info, value)

									if( value ) then

										setVariable(info[2], nil, nil, "hideAnyRaid", false)

									end



									setVariable(info[2], nil, nil, "hideSemiRaid", value)

									ShadowUF.Units:ReloadHeader(info[#(info) - 3])

								end,

								arg = "hideSemiRaid",

							},

							hideRaid = {

								order = 2,

								type = "toggle",

								name = L["Hide in any raid"],

								desc = L["Party frames are hidden while in any sort of raid no matter how many people."],

								hidden = function(info) return info[2] ~= "party" end,

								set = function(info, value)

									if( value ) then

										setVariable(info[2], nil, nil, "hideSemiRaid", false)

									end



									setVariable(info[2], nil, nil, "hideAnyRaid", value)

									ShadowUF.Units:ReloadHeader(info[#(info) - 3])

								end,

								arg = "hideAnyRaid",

							},

							separateFrames = {

								order = 3,

								type = "toggle",

								name = L["Separate raid frames"],

								desc = L["Splits raid frames into individual frames for each raid group instead of one single frame.|nNOTE! You cannot drag each group frame individualy, but how they grow is set through the column and row growth options."],

								hidden = function(info) return info[2] ~= "raid" end,	

								arg = "frameSplit",

							},

							hideSemiRaidRaid = {

								order = 3.5,

								type = "toggle",

								name = L["Hide in <=5-man raids"],

								desc = L["Raid frames are hidden while in a raid group with 5 or less people inside."],

								hidden = function(info) return info[2] ~= "raid" end,

								set = function(info, value)

									setVariable(info[2], nil, nil, "hideSemiRaid", value)

									ShadowUF.Units:ReloadHeader(info[#(info) - 3])

								end,

								arg = "hideSemiRaid"

							},

							showInRaid = {

								order = 4,

								type = "toggle",

								name = L["Show party as raid"],

								hidden = hideRaidOption,

								set = function(info, value)

									setUnit(info, value)

									

									ShadowUF.Units:ReloadHeader("party")

									ShadowUF.Units:ReloadHeader("raid")

									ShadowUF.modules.movers:Update()

								end,

								arg = "showParty",

							},

						},

					},

					general = {

						order = 1,

						type = "group",

						inline = true,

						name = L["General"],

						hidden = false,

						args = {

							offset = {

								order = 2,

								type = "range",

								name = L["Row offset"],

								desc = L["Spacing between each row"],

								min = -10, max = 100, step = 1,

								arg = "offset",

							},

							attribPoint = {

								order = 3,

								type = "select",

								name = L["Row growth"],

								desc = L["How the rows should grow when new group members are added."],

								values = {["TOP"] = L["Down"], ["BOTTOM"] = L["Up"], ["LEFT"] = L["Right"], ["RIGHT"] = L["Left"]},

								arg = "attribPoint",

								set = function(info, value)

									-- If you set the frames to grow left, the columns have to grow down or up as well

									local attribAnchorPoint = getVariable(info[2], nil, nil, "attribAnchorPoint")

									if( ( value == "LEFT" or value == "RIGHT" ) and attribAnchorPoint ~= "BOTTOM" and attribAnchorPoint ~= "TOP" ) then

										ShadowUF.db.profile.units[info[2]].attribAnchorPoint = "BOTTOM"

									elseif( ( value == "TOP" or value == "BOTTOM" ) and attribAnchorPoint ~= "LEFT" and attribAnchorPoint ~= "RIGHT" ) then

										ShadowUF.db.profile.units[info[2]].attribAnchorPoint = "RIGHT"

									end

									

									setUnit(info, value)



									local position = ShadowUF.db.profile.positions[info[2]]

									if( position.top and position.bottom ) then

										local point = ShadowUF.db.profile.units[info[2]].attribAnchorPoint == "RIGHT" and "RIGHT" or "LEFT"

										position.point = (ShadowUF.db.profile.units[info[2]].attribPoint == "BOTTOM" and "BOTTOM" or "TOP") .. point

										position.y = ShadowUF.db.profile.units[info[2]].attribPoint == "BOTTOM" and position.bottom or position.top

									end



									ShadowUF.Units:ReloadHeader(info[2])

									ShadowUF.modules.movers:Update()

								end,

							},

							sep2 = { 

								order = 4,

								type = "description",

								name = "",

								width = "full",

								hidden = false,

							},

							columnSpacing = {

								order = 5,

								type = "range",

								name = L["Column spacing"],

								min = -30, max = 100, step = 1,

								hidden = hideRaidOrAdvancedOption,

								arg = "columnSpacing",

							},

							attribAnchorPoint = {

								order = 6,

								type = "select",

								name = L["Column growth"],

								desc = L["How the frames should grow when a new column is added."],

								values = function(info)

									local attribPoint = getVariable(info[2], nil, nil, "attribPoint")

									if( attribPoint == "LEFT" or attribPoint == "RIGHT" ) then

										return {["TOP"] = L["Down"], ["BOTTOM"] = L["Up"]}

									end

									

									return {["LEFT"] = L["Right"], ["RIGHT"] = L["Left"]}

								end,

								hidden = hideRaidOrAdvancedOption,

								set = function(info, value)

									-- If you set the frames to grow left, the columns have to grow down or up as well

									local attribPoint = getVariable(info[2], nil, nil, "attribPoint")

									if( ( value == "LEFT" or value == "RIGHT" ) and attribPoint ~= "BOTTOM" and attribPoint ~= "TOP" ) then

										ShadowUF.db.profile.units[info[2]].attribPoint = "BOTTOM"

									end

								

									setUnit(info, value)



									ShadowUF.Units:ReloadHeader(info[2])

									ShadowUF.modules.movers:Update()

								end,

								arg = "attribAnchorPoint",

							},

							sep3 = { 

								order = 7,

								type = "description",

								name = "",

								width = "full",

								hidden = false,

							},

							maxColumns = {

								order = 8,

								type = "range",

								name = L["Max columns"],

								min = 1, max = 20, step = 1,

								arg = "maxColumns",

								hidden = function(info) return info[2] == "boss" or info[2] == "arena" or hideSplitOrRaidOption(info) end,

							},

							unitsPerColumn = {

								order = 8,

								type = "range",

								name = L["Units per column"],

								min = 1, max = 40, step = 1,

								arg = "unitsPerColumn",

								hidden = function(info) return info[2] == "boss" or info[2] == "arena" or hideSplitOrRaidOption(info) end,

							},

							partyPerColumn = {

								order = 9,

								type = "range",

								name = L["Units per column"],

								min = 1, max = 5, step = 1,

								arg = "unitsPerColumn",

								hidden = function(info) return info[2] ~= "party" or not ShadowUF.db.profile.advanced end,

							},

							groupsPerRow = {

								order = 8,

								type = "range",

								name = L["Groups per row"],

								desc = L["How many groups should be shown per row."],

								min = 1, max = 8, step = 1,

								arg = "groupsPerRow",

								hidden = function(info) return info[2] ~= "raid" or not ShadowUF.db.profile.units.raid.frameSplit end,

							},

							groupSpacing = {

								order = 9,

								type = "range",

								name = L["Group row spacing"],

								desc = L["How much spacing should be between each new row of groups."],

								min = -50, max = 50, step = 1,

								arg = "groupSpacing",

								hidden = function(info) return info[2] ~= "raid" or not ShadowUF.db.profile.units.raid.frameSplit end,

							},

						},

					},

					sort = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Sorting"],

						hidden = function(info) return info[2] == "boss" or info[2] == "arena" or ( info[2] ~= "raid" and not ShadowUF.db.profile.advanced ) end,

						args = {

							sortMethod = {

								order = 2,

								type = "select",

								name = L["Sort method"],

								values = {["INDEX"] = L["Index"], ["NAME"] = L["Name"]},

								arg = "sortMethod",

								hidden = false,

							},

							sortOrder = {

								order = 2,

								type = "select",

								name = L["Sort order"],

								values = {["ASC"] = L["Ascending"], ["DESC"] = L["Descending"]},

								arg = "sortOrder",

								hidden = false,

							},

						},

					},

					raid = {

						order = 3,

						type = "group",

						inline = true,

						name = L["Groups"],

						hidden = hideRaidOption,

						args = {

							groupBy = {

								order = 4,

								type = "select",

								name = L["Group by"],

								values = {["GROUP"] = L["Group number"], ["CLASS"] = L["Class"]},

								arg = "groupBy",

								hidden = hideSplitOrRaidOption,

							},

							sortMethod = {

								order = 5,

								type = "select",

								name = L["Sort method"],

								values = {["INDEX"] = L["Index"], ["NAME"] = L["Name"]},

								arg = "sortMethod",

								hidden = false,

							},

							sortOrder = {

								order = 6,

								type = "select",

								name = L["Sort order"],

								values = {["ASC"] = L["Ascending"], ["DESC"] = L["Descending"]},

								arg = "sortOrder",

								hidden = false,

							},

							selectedGroups = {

								order = 7,

								type = "multiselect",

								name = L["Groups to show"],

								values = {string.format(L["Group %d"], 1), string.format(L["Group %d"], 2), string.format(L["Group %d"], 3), string.format(L["Group %d"], 4), string.format(L["Group %d"], 5), string.format(L["Group %d"], 6), string.format(L["Group %d"], 7), string.format(L["Group %d"], 8)},

								set = function(info, key, value)

									local tbl = getVariable(info[2], nil, nil, "filters")

									tbl[key] = value

									

									setVariable(info[2], "filters", nil, tbl)

									ShadowUF.Units:ReloadHeader(info[2])

									ShadowUF.modules.movers:Update()

								end,

								get = function(info, key)

									return getVariable(info[2], nil, nil, "filters")[key]

								end,

								hidden = function(info) return info[2] ~= "raid" and info[2] ~= "raidpet" end,

							},

						},

					},

				},

			},

			frame = {

				order = 2,

				name = L["Frame"],

				type = "group",

				hidden = isModifiersSet,

				set = setUnit,

				get = getUnit,

				args = {

					size = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Size"],

						hidden = false,

						set = function(info, value)

							setUnit(info, value)

							ShadowUF.modules.movers:Update()

						end,

						args = {

							scale = {

								order = 0,

								type = "range",

								name = L["Scale"],

								min = 0.25, max = 2, step = 0.01,

								isPercent = true,

								arg = "scale",

							},

							height = {

								order = 1,

								type = "range",

								name = L["Height"],

								min = 0, softMax = 100, step = 1,

								arg = "height",

							},

							width = {

								order = 2,

								type = "range",

								name = L["Width"],

								min = 0, softMax = 300, step = 1,

								arg = "width",

							},

						},

					},

					anchor = {

						order = 1,

						type = "group",

						inline = true,

						hidden = function(info) return info[2] == "global" end,

						name = L["Anchor to another frame"],

						set = setPosition,

						get = getPosition,

						args = {

							anchorPoint = {

								order = 0.50,

								type = "select",

								name = L["Anchor point"],

								values = positionList,

								hidden = false,

								get = function(info)

									local position = ShadowUF.db.profile.positions[info[2]]

									if( ShadowUF.db.profile.advanced ) then

										return position[info[#(info)]]

									end

									

									

									return position.movedAnchor or position[info[#(info)]]

								end,

							},

							anchorTo = {

								order = 1,

								type = "select",

								name = L["Anchor to"],

								values = getAnchorParents,

								hidden = false,

							},

							sep = {

								order = 2,

								type = "description",

								name = "",

								width = "full",

								hidden = false,

							},

							x = {

								order = 3,

								type = "input",

								name = L["X Offset"],

								validate = checkNumber,

								set = setNumber,

								get = getString,

								hidden = false,

							},

							y = {

								order = 4,

								type = "input",

								name = L["Y Offset"],

								validate = checkNumber,

								set = setNumber,

								get = getString,

								hidden = false,

							},

						},

					},

					orHeader = {

						order = 1.5,

						type = "header",

						name = L["Or you can set a position manually"],

						hidden = function(info) if( info[2] == "global" or hideAdvancedOption() ) then return true else return false end end,

					},

					position = {

						order = 2,

						type = "group",

						hidden = function(info) if( info[2] == "global" or hideAdvancedOption() ) then return true else return false end end,

						inline = true,

						name = L["Manual position"],

						set = setPosition,

						get = getPosition,

						args = {

							point = {

								order = 0,

								type = "select",

								name = L["Point"],

								values = pointPositions,

								hidden = false,

							},

							anchorTo = {

								order = 0.50,

								type = "select",

								name = L["Anchor to"],

								values = getAnchorParents,

								hidden = false,

							},

							relativePoint = {

								order = 1,

								type = "select",

								name = L["Relative point"],

								values = pointPositions,

								hidden = false,

							},

							sep = {

								order = 2,

								type = "description",

								name = "",

								width = "full",

								hidden = false,

							},

							x = {

								order = 3,

								type = "input",

								name = L["X Offset"],

								validate = checkNumber,

								set = setNumber,

								get = getString,

								hidden = false,

							},

							y = {

								order = 4,

								type = "input",

								name = L["Y Offset"],

								validate = checkNumber,

								set = setNumber,

								get = getString,

								hidden = false,

							},

						},

					},

				},

			},

			bars = {

				order = 3,

				name = L["Bars"],

				type = "group",

				hidden = isModifiersSet,

				set = setUnit,

				get = getUnit,

				args = {

					powerbar = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Power bar"],

						hidden = false,

						args = {

							powerBar = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Power bar"]),

								arg = "powerBar.enabled",

							},

							predictPower = {

								order = 2,

								type = "toggle",

								name = L["Enable quick power"],

								desc = L["Turns fast updating of the power bar on giving you more up to date power information than normal."],

								arg = "powerBar.predicted",

							},

							altPowerBar = {

								order = 3,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Alt. Power bar"]),

								desc = L["Shows a bar for alternate power info (used in some encounters)"],

								hidden = hideRestrictedOption,

								arg = "altPowerBar.enabled",

							},

							sep = { 

								order = 4,

								type = "description",

								name = "",

								width = "full",

								hidden = false,

							},

							colorType = {

								order = 5,

								type = "select",

								name = L["Color power by"],

								desc = L["Primary means of coloring the power bar. Coloring by class only applies to players, for non-players it will default to the power type."],

								values = {["class"] = L["Class"], ["type"] = L["Power Type"]},

								arg = "powerBar.colorType",

							}

						},

					},

					classmiscbars = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Class/misc bars"],

						hidden = function(info) 

							local unit = info[2]

							if( unit == "global" ) then

								return not globalConfig.runeBar and not globalConfig.eclipseBar and not globalConfig.totemBar and not globalConfig.druidBar and not globalConfig.xpBar

							else

								return unit ~= "player"

							end

						end,

						args = {

							runeBar = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Rune bar"]),

								desc = L["Adds rune bars and timers before runes refresh to the player frame."],

								hidden = hideRestrictedOption,

								arg = "runeBar.enabled",

							},

							eclipseBar = {

								order = 1.25,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Eclipse bar"]),

								desc = L["Adds eclipse bars and how far into sun or moon eclipse is.."],

								hidden = hideRestrictedOption,

								arg = "eclipseBar.enabled",

							},

							totemBar = {

								order = 1.5,

								type = "toggle",

								name = string.format(L["Enable %s"], ShadowUF.modules.totemBar.moduleName),

								desc = function(info)

									return select(2, UnitClass("player")) == "SHAMAN" and L["Adds totem bars with timers before they expire to the player frame."] or select(2, UnitClass("player")) == "DEATHKNIGHT" and L["Adds a bar indicating how much time is left on your ghoul timer, only used if you do not have a permanent ghoul."] or L["Adds a bar indicating how much time is left on your mushrooms."]

								end,

								hidden = hideRestrictedOption,

								arg = "totemBar.enabled",

							},

							druidBar = {

								order = 3,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Druid mana bar"]),

								desc = L["Adds another mana bar to the player frame when you are in Bear or Cat form showing you how much mana you have."],

								hidden = hideRestrictedOption,

								arg = "druidBar.enabled",

							},

							xpBar = {

								order = 4,

								type = "toggle",

								name = string.format(L["Enable %s"], L["XP/Rep bar"]),

								desc = L["This bar will automatically hide when you are at the level cap, or you do not have any reputations tracked."],

								hidden = hideRestrictedOption,

								arg = "xpBar.enabled",

							},

						},

					},

					healthBar = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Health bar"],

						hidden = false,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Health bar"]),

								arg = "healthBar.enabled",

							},

							sep = {

								order = 3.5,

								type = "description",

								name = "",

							},

							healthColor = {

								order = 4,

								type = "select",

								name = L["Color health by"],

								desc = L["Primary means of coloring the health bar, color on aggro and color by reaction will override this if necessary."],

								values = {["class"] = L["Class"], ["static"] = L["Static"], ["percent"] = L["Health percent"]},

								arg = "healthBar.colorType",

							},

							reaction = {

								order = 5,

								type = "select",

								name = L["Color by reaction on"],

								desc = L["When to color the health bar by the units reaction, overriding the color health by option."],

								arg = "healthBar.reactionType",

								values = {["none"] = L["Never (Disabled)"], ["player"] = L["Players only"], ["npc"] = L["NPCs only"], ["both"] = L["Both"]},

								hidden = function(info) return info[2] == "player" or info[2] == "pet" end,

							},

							colorAggro = {

								order = 6,

								type = "toggle",

								name = L["Color on aggro"],

								desc = L["Changes the health bar to the set hostile color (Red by default) when the unit takes aggro."],

								arg = "healthBar.colorAggro",

								hidden = hideRestrictedOption,

							},

						},

					},

					incHeal = {

						order = 3,

						type = "group",

						inline = true,

						-- name = L["Incoming heals and absorbs"],

						name = L["Incoming heals"],

						hidden = hideRestrictedOption,

						disabled = function(info) return not getVariable(info[2], "healthBar", nil, "enabled") end,

						args = {

							heals = {

								order = 1,

								type = "toggle",

								name = L["Show incoming heals"],

								desc = L["Adds a bar inside the health bar indicating how much healing someone will receive."],

								arg = "incHeal.heals",

								hidden = false,

								set = function(info, value)

									setUnit(info, value)

									setDirectUnit(info[2], "incHeal", nil, "enabled", getVariable(info[2], "incHeal", nil, "absorbs") or getVariable(info[2], "incHeal", nil, "heals"))

								end

							},

							-- absorbs = {

							-- 	order = 2,

							-- 	type = "toggle",

							-- 	name = L["Show current absorbs"],

							-- 	desc = L["Adds a bar inside the health bar indicating how much damage absorbed they have."],

							-- 	arg = "incHeal.absorbs",

							-- 	hidden = false,

							-- 	set = function(info, value)

							-- 		setUnit(info, value)

							-- 		setDirectUnit(info[2], "incHeal", nil, "enabled", getVariable(info[2], "incHeal", nil, "absorbs") or getVariable(info[2], "incHeal", nil, "heals"))

							-- 	end

							-- },

							cap = {

								order = 3,

								type = "range",

								name = L["Outside bar limit"],

								desc = L["Percentage value of how far outside the unit frame the incoming heal bar can go. 130% means it will go 30% outside the frame, 100% means it will not go outside."],

								min = 1, max = 1.50, step = 0.05, isPercent = true,

								arg = "incHeal.cap",

								hidden = false,

							},

						},

					},

					emptyBar = {

						order = 4,

						type = "group",

						inline = true,

						name = L["Empty bar"],

						hidden = false,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Empty bar"]),

								desc = L["Adds an empty bar that you can put text into as a way of uncluttering other bars."],

								arg = "emptyBar.enabled",

								width = "full",

							},

							reaction = {

								order = 2,

								type = "select",

								name = L["Color by reaction on"],

								desc = L["When to color the empty bar by reaction, overriding the default color by option."],

								arg = "emptyBar.reactionType",

								values = {["none"] = L["Never (Disabled)"], ["player"] = L["Players only"], ["npc"] = L["NPCs only"], ["both"] = L["Both"]},

							},

							colorType = {

								order = 3,

								type = "toggle",

								name = L["Color by class"],

								desc = L["Players will be colored by class."],

								arg = "emptyBar.class",

							},

							overrideColor = {

								order = 4,

								type = "color",

								name = L["Background color"],

								disabled = function(info)

									local emptyBar = getVariable(info[2], nil, nil, "emptyBar") 

									return emptyBar.class and emptyBar.reaciton

								end,

								set = function(info, r, g, b)

									local color = getUnit(info) or {}

									color.r = r

									color.g = g

									color.b = b

									

									setUnit(info, color)

								end,

								get = function(info)

									local color = getUnit(info)

									if( not color ) then

										return 0, 0, 0

									end

									

									return color.r, color.g, color.b



								end,

								arg = "emptyBar.backgroundColor",

							},

						},

					},

					castBar = {

						order = 5,

						type = "group",

						inline = true,

						name = L["Cast bar"],

						hidden = hideRestrictedOption,

						args = {

							enabled = {

								order = 1,

								type = "toggle",

								name = string.format(L["Enable %s"], L["Cast bar"]),

								desc = function(info) return ShadowUF.fakeUnits[info[2]] and string.format(L["Due to the nature of fake units, cast bars for %s are not super efficient and can take at most 0.10 seconds to notice a change in cast."], L.units[info[2]] or info[2]) end,

								hidden = false,

								arg = "castBar.enabled",

							},

							autoHide = {

								order = 2,

								type = "toggle",

								name = L["Hide bar when empty"],

								desc = L["Hides the cast bar if there is no cast active."],

								hidden = false,

								arg = "castBar.autoHide",

							},

							castIcon = {

								order = 2.5,

								type = "select",

								name = L["Cast icon"],

								arg = "castBar.icon",

								values = {["LEFT"] = L["Left"], ["RIGHT"] = L["Right"], ["HIDE"] = L["Disabled"]},

								hidden = false,

							},

							castName = {

								order = 3,

								type = "header",

								name = L["Cast name"],

								hidden = hideAdvancedOption,

							},

							nameEnabled = {

								order = 4,

								type = "toggle",

								name = L["Show cast name"],

								arg = "castBar.name.enabled",

								hidden = hideAdvancedOption,

							},

							rankEnabled = {

								order = 4.5,

								type = "toggle",

								name = L["Show cast rank"],

								arg = "castBar.name.rank",

								hidden = hideAdvancedOption,

								disabled = disableIfCastName,

							},

							nameAnchor = {

								order = 5,

								type = "select",

								name = L["Anchor point"],

								desc = L["Where to anchor the cast name text."],

								values = {["CLI"] = L["Inside Center Left"], ["CRI"] = L["Inside Center Right"]},

								hidden = hideAdvancedOption,

								arg = "castBar.name.anchorPoint",

							},

							nameSep = {

								order = 6,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							nameSize = {

								order = 7,

								type = "range",

								name = L["Size"],

								desc = L["Let's you modify the base font size to either make it larger or smaller."],

								type = "range",

								min = -10, max = 10, step = 1, softMin = -5, softMax = 5,

								hidden = hideAdvancedOption,

								arg = "castBar.name.size",

							},

							nameX = {

								order = 8,

								type = "range",

								name = L["X Offset"],

								min = -20, max = 20, step = 1,

								hidden = hideAdvancedOption,

								arg = "castBar.name.x",

							},

							nameY = {

								order = 9,

								type = "range",

								name = L["Y Offset"],

								min = -20, max = 20, step = 1,

								hidden = hideAdvancedOption,

								arg = "castBar.name.y",

							},

							castTime = {

								order = 10,

								type = "header",

								name = L["Cast time"],

								hidden = hideAdvancedOption,

							},

							timeEnabled = {

								order = 11,

								type = "toggle",

								name = L["Show cast time"],

								arg = "castBar.time.enabled",

								hidden = hideAdvancedOption,

							},

							timeAnchor = {

								order = 12,

								type = "select",

								name = L["Anchor point"],

								desc = L["Where to anchor the cast time text."],

								values = {["CLI"] = L["Inside Center Left"], ["CRI"] = L["Inside Center Right"]},

								hidden = hideAdvancedOption,

								arg = "castBar.time.anchorPoint",

							},

							timeSep = {

								order = 13,

								type = "description",

								name = "",

								width = "full",

								hidden = hideAdvancedOption,

							},

							timeSize = {

								order = 14,

								type = "range",

								name = L["Size"],

								desc = L["Let's you modify the base font size to either make it larger or smaller."],

								type = "range",

								min = -10, max = 10, step = 1, softMin = -5, softMax = 5,

								hidden = hideAdvancedOption,

								arg = "castBar.time.size",

							},

							timeX = {

								order = 15,

								type = "range",

								name = L["X Offset"],

								min = -20, max = 20, step = 1,

								hidden = hideAdvancedOption,

								arg = "castBar.time.x",

							},

							timeY = {

								order = 16,

								type = "range",

								name = L["Y Offset"],

								min = -20, max = 20, step = 1,

								hidden = hideAdvancedOption,

								arg = "castBar.time.y",

							},

						},

					},

				},

			},

			widgetSize = {

				order = 4,

				name = L["Widget size"],

				type = "group",

				hidden = isModifiersSet,

				set = setUnit,

				get = getUnit,

				args = {

					help = {

						order = 0,

						type = "group",

						name = L["Help"],

						inline = true,

						hidden = false,

						args = {

							help = {

								order = 0,

								type = "description",

								name = L["Bars with an order higher or lower than the full size options will use the entire unit frame width.|n|nBar orders between those two numbers are shown next to the portrait."],

							},

						},

					},

					portrait = {

						order = 0.5,

						type = "group",

						name = L["Portrait"],

						inline = true,

						hidden = false,

						args = {

							enableBar = {

								order = 1,

								type = "toggle",

								name = L["Show as bar"],

								desc = L["Changes this widget into a bar, you will be able to change the height and ordering like you can change health and power bars."],

								arg = "$parent.isBar",

							},

							sep = {

								order = 1.5,

								type = "description",

								name = "",

								width = "full",

								hidden = function(info) return getVariable(info[2], "portrait", nil, "isBar") end,

							},

							width = {

								order = 2,

								type = "range",

								name = L["Width percent"],

								desc = L["Percentage of width the portrait should use."],

								min = 0, max = 1.0, step = 0.01, isPercent = true,

								hidden = function(info) return getVariable(info[2], "portrait", nil, "isBar") end,

								arg = "$parent.width",

							},

							before = {

								order = 3,

								type = "range",

								name = L["Full size before"],

								min = 0, max = 100, step = 5,

								hidden = function(info) return getVariable(info[2], "portrait", nil, "isBar") end,

								arg = "$parent.fullBefore",

							},

							after = {

								order = 4,

								type = "range",

								name = L["Full size after"],

								min = 0, max = 100, step = 5,

								hidden = function(info) return getVariable(info[2], "portrait", nil, "isBar") end,

								arg = "$parent.fullAfter",

							},

							order = {

								order = 3,

								type = "range",

								name = L["Order"],

								min = 0, max = 100, step = 5,

								hidden = hideBarOption,

								arg = "portrait.order",

							},

							height = {

								order = 4,

								type = "range",

								name = L["Height"],

								desc = L["How much of the frames total height this bar should get, this is a weighted value, the higher it is the more it gets."],

								min = 0, max = 10, step = 0.1,

								hidden = hideBarOption,

								arg = "portrait.height",

							},

						},

					},

				},

			},

			auras = {

				order = 5,

				name = L["Auras"],

				type = "group",

				hidden = isModifiersSet,

				set = setUnit,

				get = getUnit,

				args = {

					temp = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Temporary enchants"],

						hidden = function(info) return info[2] ~= "player" end,

						args = {

							temporary = {

								order = 0,

								type = "toggle",

								name = L["Enable temporary enchants"],

								desc = L["Adds temporary enchants to the buffs for the player."],

								disabled = function(info) return not getVariable(info[2], "auras", "buffs", "enabled") end,

								arg = "auras.buffs.temporary",

								width = "double",

							},

						},

					},

					buffs = Config.auraTable,

					debuffs = Config.auraTable,

				},

			},

			indicators = {

				order = 5.5,

				type = "group",

				name = L["Indicators"],

				hidden = isModifiersSet,

				childGroups = "tree",

				set = setUnit,

				get = getUnit,

				args = {

				},

			},

			tag = {

				order = 7,

				name = L["Text/Tags"],

				type = "group",

				hidden = isModifiersSet,

				childGroups = "tree",

				args = tagWizard,

			},

		},

	}

	

	for _, indicator in pairs(ShadowUF.modules.indicators.list) do

		Config.unitTable.args.indicators.args[indicator] = Config.indicatorTable

	end

	

	-- Check for unit conflicts

	local function hideZoneConflict()

		for _, zone in pairs(ShadowUF.db.profile.visibility) do

			for unit, status in pairs(zone) do

				if( L.units[unit] and ( not status and ShadowUF.db.profile.units[unit].enabled or status and not ShadowUF.db.profile.units[unit].enabled ) ) then

					return nil

				end

			end

		end

	

		return true

	end

	

	options.args.enableUnits = {

		type = "group",

		name = L["Enabled units"],

		desc = getPageDescription,

		args = {

			help = {

				order = 1,

				type = "group",

				inline = true,

				name = L["Help"],

				hidden = function()

					if( not hideZoneConflict() or hideBasicOption() ) then

						return true

					end

					

					return nil

				end,

				args = {

					help = {

						order = 0,

						type = "description",

						name = L["The check boxes below will allow you to enable or disable units."],

					},

				},

			},

			zoneenabled = {

				order = 1.5,

				type = "group",

				inline = true,

				name = L["Zone configuration units"],

				hidden = hideZoneConflict,

				args = {

					help = {

						order = 1,

						type = "description",

						name = L["|cffff2020Warning!|r Some units have overrides set in zone configuration, and may show (or not show up) in certain zone. Regardless of the settings below."]

					},

					sep = {

						order = 2,

						type = "header",

						name = "",

					},

					units = {

						order = 3,

						type = "description",

						name = function()

							local text = {}

						

							for zoneType, zone in pairs(ShadowUF.db.profile.visibility) do

								local errors = {}

								for unit, status in pairs(zone) do

									if( L.units[unit] ) then

										if ( not status and ShadowUF.db.profile.units[unit].enabled ) then

											table.insert(errors, string.format(L["|cffff2020%s|r units disabled"], L.units[unit]))

										elseif( status and not ShadowUF.db.profile.units[unit].enabled ) then

											table.insert(errors, string.format(L["|cff20ff20%s|r units enabled"], L.units[unit]))

										end

									end

								end

								

								if( #(errors) > 1 ) then

									table.insert(text, string.format("|cfffed000%s|r have the following overrides: %s", AREA_NAMES[zoneType], table.concat(errors, ", ")))

								elseif( #(errors) == 1 ) then

									table.insert(text, string.format("|cfffed000%s|r has the override: %s", AREA_NAMES[zoneType], errors[1]))

								end

							end

							

							return #(text) > 0 and table.concat(text, "|n") or ""

						end,

					},

				},

			},

			enabled = {

				order = 2,

				type = "group",

				inline = true,

				name = L["Enable units"],

				args = {},

			},

		},

	}

	

	local sort_units = function(a, b)

		return a < b

	end

	

	options.args.units = {

		type = "group",

		name = L["Unit configuration"],

		desc = getPageDescription,

		args = {

			help = {

				order = 1,

				type = "group",

				inline = true,

				name = L["Help"],

				args = {

					help = {

						order = 0,

						type = "description",

						name = L["Wondering what all of the tabs for the unit configuration mean? Here's some information:|n|n|cfffed000General:|r Portrait, range checker, combat fader, border highlighting|n|cfffed000Frame:|r Unit positioning and frame anchoring|n|cfffed000Bars:|r Health, power, empty and cast bar, and combo point configuration|n|cfffed000Widget size:|r All bar and portrait sizing and ordering options|n|cfffed000Auras:|r All aura configuration for enabling/disabling/enlarging self/etc|n|cfffed000Indicators:|r All indicator configuration|n|cfffed000Text/Tags:|r Tag management as well as text positioning and width settings.|n|n|n*** Frequently looked for options ***|n|n|cfffed000Raid frames by group|r - Unit configuration -> Raid -> Raid -> Separate raid frames|n|cfffed000Class coloring:|r Bars -> Color health by|n|cfffed000Timers on auras:|r You need OmniCC for that|n|cfffed000Showing/Hiding default buff frames:|r Hide Blizzard -> Hide buff frames|n|cfffed000Percentage HP/MP text:|r Tags/Text tab, use the [percenthp] or [percentpp] tags|n|cfffed000Hiding party based on raid|r - Unit configuration -> Party -> Party -> Hide in 6-man raid/Hide in any raid"],

						fontSize = "medium",

					},

				},

			},

			global = {

				type = "group",

				childGroups = "tab",

				order = 0,

				name = L["Global"],

				args = {

					test = {

						order = 0,

						type = "group",

						name = L["Currently modifying"],

						inline = true,

						hidden = function()

							for k in pairs(modifyUnits) do return false end

							return true

						end,

						args = {

							info = {

								order = 0,

								type = "description",

								name = function()

									local units = {};

									for unit, enabled in pairs(modifyUnits) do

										if( enabled ) then

											table.insert(units, L.units[unit])

										end

									end

									

									table.sort(units, sort_units)

									return table.concat(units, ", ")

								end,

							}

						}

					},

					units = {

						order = 1,

						type = "group",

						name = L["Units"],

						set = function(info, value)

							local unit = info[#(info)]

							if( IsShiftKeyDown() ) then

								for _, unit in pairs(ShadowUF.unitList) do

									if( ShadowUF.db.profile.units[unit].enabled ) then

										modifyUnits[unit] = value and true or nil

										

										if( value ) then

											globalConfig = mergeTables(globalConfig, ShadowUF.db.profile.units[unit])

										end

									end

								end

							else

								modifyUnits[unit] = value and true or nil



								if( value ) then

									globalConfig = mergeTables(globalConfig, ShadowUF.db.profile.units[unit])

								end

							end

							

							-- Check if we have nothing else selected, if so wipe it

							local hasUnit

							for k in pairs(modifyUnits) do hasUnit = true break end

							if( not hasUnit ) then

								globalConfig = {}

							end

							

							AceRegistry:NotifyChange("ShadowedUF")

						end,

						get = function(info) return modifyUnits[info[#(info)]] end,

						args = {

							help = {

								order = 0,

								type = "group",

								name = L["Help"],

								inline = true,

								args = {

									help = {

										order = 0,

										type = "description",

										name = L["Select the units that you want to modify, any settings changed will change every unit you selected. If you want to anchor or change raid/party unit specific settings you will need to do that through their options.|n|nShift click a unit to select all/unselect all."],

									},

								},

							},

							units = {

								order = 1,

								type = "group",

								name = L["Units"],

								inline = true,

								args = {},

							},

						},

					},

				},

			},

		},

	}

	

	-- Load modules into the unit table

	for key, module in pairs(ShadowUF.modules) do

		local canHaveBar = module.moduleHasBar

		for _, data in pairs(ShadowUF.defaults.profile.units) do

			if( data[key] and data[key].isBar ~= nil ) then

				canHaveBar = true

			end

		end

		

		if( canHaveBar ) then

			Config.unitTable.args.widgetSize.args[key] = Config.barTable

		end

	end



	-- Load global unit

	for k, v in pairs(Config.unitTable.args) do

		options.args.units.args.global.args[k] = v

	end



	-- Load all of the per unit settings

	local perUnitList = {

		order = getUnitOrder,

		type = "toggle",

		name = getName,

		hidden = isUnitDisabled,

		desc = function(info)

			return string.format(L["Adds %s to the list of units to be modified when you change values in this tab."], L.units[info[#(info)]])

		end,

	}

	

	-- Enabled units list

	local unitCatOrder = {}

	local enabledUnits = {

		order = function(info) return unitCatOrder[info[#(info)]] + getUnitOrder(info) end,

		type = "toggle",

		name = getName,

		set = function(info, value)

			local unit = info[#(info)]

			for child, parent in pairs(ShadowUF.Units.childUnits) do

				if( unit == parent and not value ) then

					ShadowUF.db.profile.units[child].enabled = false

				end

			end

			

			ShadowUF.modules.movers:Update()

			ShadowUF.db.profile.units[unit].enabled = value

			ShadowUF:LoadUnits()



			-- Update party frame visibility

			if( unit == "raid" and ShadowUF.Units.headerFrames.party ) then

				ShadowUF.Units:SetHeaderAttributes(ShadowUF.Units.headerFrames.party, "party")

			end

			

			ShadowUF.modules.movers:Update()

		end,

		get = function(info)

			return ShadowUF.db.profile.units[info[#(info)]].enabled

		end,

		desc = function(info)

			local unit = info[#(info)]

			local unitDesc = UNIT_DESC[unit] or ""

			

			if( ShadowUF.db.profile.units[unit].enabled and ShadowUF.Units.childUnits[unit] ) then

				if( unitDesc ~= "" ) then unitDesc = unitDesc .. "\n\n" end

				return unitDesc .. string.format(L["This unit depends on another to work, disabling %s will disable %s."], L.units[ShadowUF.Units.childUnits[unit]], L.units[unit])

			elseif( not ShadowUF.db.profile.units[unit].enabled ) then 

				for child, parent in pairs(ShadowUF.Units.childUnits) do

					if( parent == unit ) then

						if( unitDesc ~= "" ) then unitDesc = unitDesc .. "\n\n" end

						return unitDesc .. L["This unit has child units that depend on it, you need to enable this unit before you can enable its children."]

					end

				end

			end

			

			return unitDesc ~= "" and unitDesc

		end,

		disabled = function(info)

			local unit = info[#(info)]

			if( ShadowUF.Units.childUnits[unit] ) then

				return not ShadowUF.db.profile.units[ShadowUF.Units.childUnits[unit]].enabled	

			end

			

			return false

		end,

	}

	

	local unitCategory = {

		order = function(info)

			local cat = info[#(info)]

			return cat == "playercat" and 50 or cat == "generalcat" and 100 or cat == "partycat" and 200 or cat == "raidcat" and 300 or 400

		end,

		type = "header",

		name = function(info)

			local cat = info[#(info)]

			return cat == "playercat" and L["Player"] or cat == "generalcat" and L["General"] or cat == "raidcat" and L["Raid"] or cat == "partycat" and L["Party"] or cat == "arenacat" and L["Arena"]

		end,

		width = "full",

	}

	

	for cat, list in pairs(unitCategories) do

		options.args.enableUnits.args.enabled.args[cat .. "cat"] = unitCategory



		for _, unit in pairs(list) do

			unitCatOrder[unit] = cat == "player" and 50 or cat == "general" and 100 or cat == "party" and 200 or cat == "raid" and 300 or 400

		end

	end



	for order, unit in pairs(ShadowUF.unitList) do

		options.args.enableUnits.args.enabled.args[unit] = enabledUnits

		options.args.units.args.global.args.units.args.units.args[unit] = perUnitList

		options.args.units.args[unit] = Config.unitTable

		

		unitCatOrder[unit] = unitCatOrder[unit] or 100

	end

end



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

-- FILTER CONFIGURATION

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

local function loadFilterOptions()

	local hasWhitelist, hasBlacklist, rebuildFilters

	local filterMap, spellMap = {}, {}



	local manageFiltersTable = {

		order = function(info) return info[#(info)] == "whitelists" and 1 or 2 end,

		type = "group",

		name = function(info) return info[#(info)] == "whitelists" and L["Whitelists"] or L["Blacklists"] end,

		args = {

		},

	}

	

	local function reloadUnitAuras()

		for _, frame in pairs(ShadowUF.Units.unitFrames) do

			if( UnitExists(frame.unit) and frame.visibility.auras ) then

				ShadowUF.modules.auras:UpdateFilter(frame)

				frame:FullUpdate()

			end

		end

	end

	

	local function setFilterType(info, value)

		local filter = filterMap[info[#(info) - 2]]

		local filterType = info[#(info) - 3]

		

		ShadowUF.db.profile.filters[filterType][filter][info[#(info)]] = value

		reloadUnitAuras()

	end

	

	local function getFilterType(info)

		local filter = filterMap[info[#(info) - 2]]

		local filterType = info[#(info) - 3]

		

		return ShadowUF.db.profile.filters[filterType][filter][info[#(info)]]

	end

	

	--- Container widget for the filter listing

	local filterEditTable = {

		order = 0,

		type = "group",

		name = function(info) return filterMap[info[#(info)]] end,

		hidden = function(info) return not ShadowUF.db.profile.filters[info[#(info) - 1]][filterMap[info[#(info)]]] end,

		args = {

			general = {

				order = 0,

				type = "group",

				name = function(info) return filterMap[info[#(info) - 1]] end,

				hidden = false,

				inline = true,

				args = {

					add = {

						order = 0,

						type = "input",

						name = L["Aura name"],

						--dialogControl = "Aura_EditBox",

						hidden = false,

						set = function(info, value)

							local filterType = info[#(info) - 3]

							local filter = filterMap[info[#(info) - 2]]



							ShadowUF.db.profile.filters[filterType][filter][value] = true



							reloadUnitAuras()

							rebuildFilters()

						end,

					},

					delete = {

						order = 1,

						type = "execute",

						name = L["Delete filter"],

						hidden = false,

						confirmText = L["Are you sure you want to delete this filter?"],

						confirm = true,

						func = function(info, value)

							local filterType = info[#(info) - 3]

							local filter = filterMap[info[#(info) - 2]]

							

							ShadowUF.db.profile.filters[filterType][filter] = nil

							

							-- Delete anything that used this filter too

							local filterList = filterType == "whitelist" and ShadowUF.db.profile.filters.zonewhite or filterType == "blacklist" and ShadowUF.db.profile.filters.zoneblack

							for id, filterUsed in pairs(filterList) do

								if( filterUsed == filter ) then

									filterList[id] = nil

								end

							end

							

							reloadUnitAuras()

							rebuildFilters()

						end,

					},

				},

			},

			filters = {

				order = 2,

				type = "group",

				inline = true,

				hidden = false,

				name = L["Aura types to filter"],

				args = {

					buffs = {

						order = 4,

						type = "toggle",

						name = L["Buffs"],

						desc = L["When this filter is active, apply the filter to buffs."],

						set = setFilterType,

						get = getFilterType,

					},

					debuffs = {

						order = 5,

						type = "toggle",

						name = L["Debuffs"],

						desc = L["When this filter is active, apply the filter to debuffs."],

						set = setFilterType,

						get = getFilterType,

					},

				},

			},

			spells = {

				order = 3,

				type = "group",

				inline = true,

				name = L["Auras"],

				hidden = false,

				args = {

				

				},

			},

		},

	}

	

	-- Spell list for manage aura filters

	local spellLabel = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) end,

		type = "description",

		-- Odd I know, AceConfigDialog-3.0 expands descriptions to full width if width is nil

		-- on the other hand we can't set width to "normal" so tricking it

		width = "", 

		fontSize = "medium",

		name = function(info) return spellMap[info[#(info)]] end,

	}

	

	local spellRow = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) + 0.5 end,

		type = "execute",

		name = L["Delete"],

		width = "half",

		func = function(info)

			local spell = spellMap[info[#(info)]]

			local filter = filterMap[info[#(info) - 2]]

			local filterType = info[#(info) - 3]

			

			ShadowUF.db.profile.filters[filterType][filter][spell] = nil

			rebuildFilters()

		end

	}



	local noSpells = {

		order = 0,

		type = "description",

		name = L["This filter has no auras in it, you will have to add some using the dialog above."],

	}



	-- The filter [View] widgets for manage aura filters

	local filterLabel = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) end,

		type = "description",

		width = "", -- Odd I know, AceConfigDialog-3.0 expands descriptions to full width if width is nil

		fontSize = "medium",

		name = function(info) return filterMap[info[#(info)]] end,

	}

	

	local filterRow = {

		order = function(info) return tonumber(string.match(info[#(info)], "(%d+)")) + 0.5 end,

		type = "execute",

		name = L["View"],

		width = "half",

		func = function(info)

			local filterType = info[#(info) - 2]

			

			AceDialog.Status.ShadowedUF.children.filter.children.filters.status.groups.groups[filterType] = true

			selectTabGroup("filter", "filters", filterType .. "\001" .. string.match(info[#(info)], "(%d+)"))

		end

	}

		

	local noFilters = {

		order = 0,

		type = "description",

		name = L["You do not have any filters of this type added yet, you will have to create one in the management panel before this page is useful."],

	}



	-- Container table for a filter zone

	local globalSettings = {}

	local zoneList = {"none", "pvp", "arena", "party", "raid"}

	local filterTable = {

		order = function(info) return info[#(info)] == "global" and 1 or info[#(info)] == "none" and 2 or 3 end,

		type = "group",

		inline = true,

		hidden = function() return not hasWhitelist and not hasBlacklist end,

		name = function(info) return AREA_NAMES[info[#(info)]] or L["Global"] end,

		set = function(info, value)

			local filter = filterMap[info[#(info)]]

			local zone = info[#(info) - 1]

			local unit = info[#(info) - 2]

			local filterKey = ShadowUF.db.profile.filters.whitelists[filter] and "zonewhite" or "zoneblack"

			

			for _, zoneConfig in pairs(zoneList) do

				if( zone == "global" or zoneConfig == zone ) then

					if( unit == "global" ) then

						globalSettings[zoneConfig .. filterKey] = value and filter or false

						

						for _, unit in pairs(ShadowUF.unitList) do

							ShadowUF.db.profile.filters[filterKey][zoneConfig .. unit] = value and filter or nil

						end

					else

						ShadowUF.db.profile.filters[filterKey][zoneConfig .. unit] = value and filter or nil

					end

				end

			end

			

			if( zone == "global" ) then

				globalSettings[zone .. unit .. filterKey] = value and filter or false

			end

			

			reloadUnitAuras()

		end,

		get = function(info)

			local filter = filterMap[info[#(info)]]

			local zone = info[#(info) - 1]

			local unit = info[#(info) - 2]

			

			if( unit == "global" or zone == "global" ) then 

				local id = zone == "global" and zone .. unit or zone

				local filterKey = ShadowUF.db.profile.filters.whitelists[filter] and "zonewhite" or "zoneblack"

				

				if( info[#(info)] == "nofilter" ) then

					return globalSettings[id .. "zonewhite"] == false and globalSettings[id .. "zoneblack"] == false

				end



				return globalSettings[id .. filterKey] == filter

			end

			

			if( info[#(info)] == "nofilter" ) then

				return not ShadowUF.db.profile.filters.zonewhite[zone .. unit] and not ShadowUF.db.profile.filters.zoneblack[zone .. unit]

			end

			

			return ShadowUF.db.profile.filters.zonewhite[zone .. unit] == filter or ShadowUF.db.profile.filters.zoneblack[zone .. unit] == filter

		end,

		args = {

			nofilter = {

				order = 0,

				type = "toggle",

				name = L["Don't use a filter"],

				hidden = false,

				set = function(info, value)

					local filter = filterMap[info[#(info)]]

					local zone = info[#(info) - 1]

					local unit = info[#(info) - 2]

				

					for _, zoneConfig in pairs(zoneList) do

						if( zone == "global" or zoneConfig == zone ) then

							if( unit == "global" ) then

								globalSettings[zoneConfig .. "zonewhite"] = false

								globalSettings[zoneConfig .. "zoneblack"] = false

								

								for _, unit in pairs(ShadowUF.unitList) do

									ShadowUF.db.profile.filters.zonewhite[zoneConfig .. unit] = nil

									ShadowUF.db.profile.filters.zoneblack[zoneConfig .. unit] = nil

								end

							else

								ShadowUF.db.profile.filters.zonewhite[zoneConfig .. unit] = nil

								ShadowUF.db.profile.filters.zoneblack[zoneConfig .. unit] = nil

							end

						end

					end



					if( zone == "global" ) then

						globalSettings[zone .. unit .. "zonewhite"] = false

						globalSettings[zone .. unit .. "zoneblack"] = false

					end



					reloadUnitAuras()

				end,

			},

			white = {

				order = 1,

				type = "header",

				name = "|cffffffff" .. L["Whitelists"] .. "|r",

				hidden = function(info) return not hasWhitelist end

			},

			black = {

				order = 3,

				type = "header",

				name = L["Blacklists"], -- In theory I would make this black, but as black doesn't work with a black background I'll skip that

				hidden = function(info) return not hasBlacklist end

			},

		},

	}

	

	-- Toggle used for set filter zones to enable filters

	local filterToggle = {

		order = function(info) return ShadowUF.db.profile.filters.whitelists[filterMap[info[#(info)]]] and 2 or 4 end,

		type = "toggle",

		name = function(info) return filterMap[info[#(info)]] end,

		desc = function(info)

			local filter = filterMap[info[#(info)]]

			filter = ShadowUF.db.profile.filters.whitelists[filter] or ShadowUF.db.profile.filters.blacklists[filter]

			if( filter.buffs and filter.debuffs ) then

				return L["Filtering both buffs and debuffs"]

			elseif( filter.buffs ) then

				return L["Filtering buffs only"]

			elseif( filter.debuffs ) then

				return L["Filtering debuffs only"]

			end

			

			return L["This filter has no aura types set to filter out."]

		end,

	}

	

	-- Load existing filters in

	-- This needs to be cleaned up later

	local filterID, spellID = 0, 0

	local function buildList(type)

		local manageFiltersTable = {

			order = type == "whitelists" and 1 or 2,

			type = "group",

			name = type == "whitelists" and L["Whitelists"] or L["Blacklists"],

			args = {

				groups = {

					order = 0,

					type = "group",

					inline = true,

					name = function(info) return info[#(info) - 1] == "whitelists" and L["Whitelist filters"] or L["Blacklist filters"] end,

					args = {

					},

				},

			},

		}

		

		local hasFilters

		for name, spells in pairs(ShadowUF.db.profile.filters[type]) do

			hasFilters = true

			filterID = filterID + 1

			filterMap[tostring(filterID)] = name

			filterMap[filterID .. "label"] = name

			filterMap[filterID .. "row"] = name

			

			manageFiltersTable.args[tostring(filterID)] = CopyTable(filterEditTable)

			manageFiltersTable.args.groups.args[filterID .. "label"] = filterLabel

			manageFiltersTable.args.groups.args[filterID .. "row"] = filterRow

			filterTable.args[tostring(filterID)] = filterToggle

			

			local hasSpells

			for spellName in pairs(spells) do

				if( spellName ~= "buffs" and spellName ~= "debuffs" ) then

					hasSpells = true

					spellID = spellID + 1

					spellMap[tostring(spellID)] = spellName

					spellMap[spellID .. "label"] = spellName

					

					manageFiltersTable.args[tostring(filterID)].args.spells.args[spellID .. "label"] = spellLabel

					manageFiltersTable.args[tostring(filterID)].args.spells.args[tostring(spellID)] = spellRow

				end

			end

			

			if( not hasSpells ) then

				manageFiltersTable.args[tostring(filterID)].args.spells.args.noSpells = noSpells

			end

		end

		

		if( not hasFilters ) then

			if( type == "whitelists" ) then hasWhitelist = nil else hasBlacklist = nil end

			manageFiltersTable.args.groups.args.noFilters = noFilters

		end

		

		return manageFiltersTable

	end

	

	rebuildFilters = function()

		for id in pairs(filterMap) do filterTable.args[id] = nil end

	

		spellID = 0

		filterID = 0

		hasBlacklist = true

		hasWhitelist = true

	

		table.wipe(filterMap)

		table.wipe(spellMap)

		

		options.args.filter.args.filters.args.whitelists = buildList("whitelists")

		options.args.filter.args.filters.args.blacklists = buildList("blacklists")

	end

		

	local unitFilterSelection = {

		order = function(info) return info[#(info)] == "global" and 1 or (getUnitOrder(info) + 1) end,

		type = "group",

		name = function(info) return info[#(info)] == "global" and L["Global"] or getName(info) end,

		disabled = function(info)

			if( info[#(info)] == "global" ) then

				return false

			end

			

			return not hasWhitelist and not hasBlacklist

		end,

		args = {

			help = {

				order = 0,

				type = "group",

				inline = true,

				name = L["Help"],

				hidden = function() return hasWhitelist or hasBlacklist end,

				args = {

					help = {

						type = "description",

						name = L["You will need to create an aura filter before you can set which unit to enable aura filtering on."],

						width = "full",

					}

				},

			},

			header = {

				order = 0,

				type = "header",

				name = function(info) return (info[#(info) - 1] == "global" and L["Global"] or L.units[info[#(info) - 1]]) end,

				hidden = function() return not hasWhitelist and not hasBlacklist end,

			},

			global = filterTable,

			none = filterTable,

			pvp = filterTable,

			arena = filterTable,

			party = filterTable,

			raid = filterTable,

		}

	}

	

	local addFilter = {type = "whitelists"}

	

	options.args.filter = {

		type = "group",

		name = L["Aura filters"],

		childGroups = "tab",

		desc = getPageDescription,

		args = {

			groups = {

				order = 1,

				type = "group",

				name = L["Set filter zones"],

				args = {

					help = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Help"],

						args = {

							help = {

								type = "description",

								name = L["You can set what unit frame should use what filter group and in what zone type here, if you want to change what auras goes into what group then see the \"Manage aura groups\" option."],

								width = "full",

							}

						},

					},

				}

			},

			filters = {

				order = 2,

				type = "group",

				name = L["Manage aura filters"],

				childGroups = "tree",

				args = {

					manage = {

						order = 1,

						type = "group",

						name = L["Management"],

						args = {

							help = {

								order = 0,

								type = "group",

								inline = true,

								name = L["Help"],

								args = {

									help = {

										type = "description",

										name = L["Whitelists will hide any aura not in the filter group.|nBlacklists will hide auras that are in the filter group."],

										width = "full",

									}

								},

							},

							error = {

								order = 1,

								type = "group",

								inline = true,

								hidden = function() return not addFilter.error end,

								name = L["Error"],

								args = {

									error = {

										order = 0,

										type = "description",

										name = function() return addFilter.error end,

										width = "full",

									},

								},

							},

							add = {

								order = 2,

								type = "group",

								inline = true,

								name = L["New filter"],

								get = function(info) return addFilter[info[#(info)]] end,

								args = {

									name = {

										order = 0,

										type = "input",

										name = L["Name"],

										set = function(info, value)

											addFilter[info[#(info)]] = string.trim(value) ~= "" and value or nil

											addFilter.error = nil

										end,

										get = function(info) return addFilter.errorName or addFilter.name end,

										validate = function(info, value)

											local name = string.lower(string.trim(value))

											for filter in pairs(ShadowUF.db.profile.filters.whitelists) do

												if( string.lower(filter) == name ) then

													addFilter.error = string.format(L["The whitelist \"%s\" already exists."], value)

													addFilter.errorName = value

													AceRegistry:NotifyChange("ShadowedUF")

													return ""

												end

											end



											for filter in pairs(ShadowUF.db.profile.filters.blacklists) do

												if( string.lower(filter) == name ) then

													addFilter.error = string.format(L["The blacklist \"%s\" already exists."], value)

													addFilter.errorName = value

													AceRegistry:NotifyChange("ShadowedUF")

													return ""

												end

											end

											

											addFilter.error = nil

											addFilter.errorName = nil

											return true

										end,

									},

									type = {

										order = 1,

										type = "select",

										name = L["Filter type"],

										set = function(info, value) addFilter[info[#(info)]] = value end,

										values = {["whitelists"] = L["Whitelist"], ["blacklists"] = L["Blacklist"]},

									},

									add = {

										order = 2,

										type = "execute",

										name = L["Create"],

										disabled = function(info) return not addFilter.name end,

										func = function(info)

											ShadowUF.db.profile.filters[addFilter.type][addFilter.name] = {buffs = true, debuffs = true}

											rebuildFilters()

											

											local id

											for key, value in pairs(filterMap) do

												if( value == addFilter.name ) then

													id = key

													break

												end

											end

											

											AceDialog.Status.ShadowedUF.children.filter.children.filters.status.groups.groups[addFilter.type] = true

											selectTabGroup("filter", "filters", addFilter.type .. "\001" .. id)

											

											table.wipe(addFilter)

											addFilter.type = "whitelists"

										end,

									},

								},

							},

						},

					},

				},

			},

		},

	}





	options.args.filter.args.groups.args.global = unitFilterSelection

	for _, unit in pairs(ShadowUF.unitList) do

		options.args.filter.args.groups.args[unit] = unitFilterSelection

	end



	rebuildFilters()

end



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

-- TAG CONFIGURATION

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

local function loadTagOptions()

	local tagData = {search = ""}

	local function set(info, value, key)

		local key = key or info[#(info)]

		if( ShadowUF.Tags.defaultHelp[tagData.name] ) then

			return

		end

		

		-- Reset loaded function + reload tags

		if( key == "funct" ) then

			ShadowUF.tagFunc[tagData.name] = nil

			ShadowUF.Tags:Reload()

		elseif( key == "category" ) then

			local cat = ShadowUF.db.profile.tags[tagData.name][key]

			if( cat and cat ~= value ) then

				Config.tagTextTable.args[cat].args[tagData.name] = nil

				Config.tagTextTable.args[value].args[tagData.name] = Config.tagTable

			end

		end



		ShadowUF.db.profile.tags[tagData.name][key] = value

	end

	

	local function stripCode(text)

		if( not text ) then

			return ""

		end

		

		return string.gsub(string.gsub(text, "|", "||"), "\t", "")

	end

	

	local function get(info, key)

		local key = key or info[#(info)]

		

		if( key == "help" and ShadowUF.Tags.defaultHelp[tagData.name] ) then

			return ShadowUF.Tags.defaultHelp[tagData.name] or ""

		elseif( key == "events" and ShadowUF.Tags.defaultEvents[tagData.name] ) then

			return ShadowUF.Tags.defaultEvents[tagData.name] or ""

		elseif( key == "frequency" and ShadowUF.Tags.defaultFrequents[tagData.name] ) then

			return ShadowUF.Tags.defaultFrequents[tagData.name] or ""

		elseif( key == "category" and ShadowUF.Tags.defaultCategories[tagData.name] ) then

			return ShadowUF.Tags.defaultCategories[tagData.name] or ""

		elseif( key == "name" and ShadowUF.Tags.defaultNames[tagData.name] ) then

			return ShadowUF.Tags.defaultNames[tagData.name] or ""

		elseif( key == "funct" and ShadowUF.Tags.defaultTags[tagData.name] ) then

			return ShadowUF.Tags.defaultTags[tagData.name] or ""

		end

				

		return ShadowUF.db.profile.tags[tagData.name] and ShadowUF.db.profile.tags[tagData.name][key] or ""

	end

		

	local function isSearchHidden(info)

		return tagData.search ~= "" and not string.match(info[#(info)], tagData.search) or false

	end

	

	local function editTag(info)

		tagData.name = info[#(info)]

		

		if( ShadowUF.Tags.defaultHelp[tagData.name] ) then

			tagData.error = L["You cannot edit this tag because it is one of the default ones included in this mod. This function is here to provide an example for your own custom tags."]

		end

		

		selectDialogGroup("tags", "edit")

	end

				

	-- Create all of the tag editor options, if it's a default tag will show it after any custom ones

	local tagTable = {

		type = "execute",

		order = function(info) return ShadowUF.Tags.defaultTags[info[#(info)]] and 100 or 1 end,

		name = getTagName,

		desc = getTagHelp,

		hidden = isSearchHidden,

		func = editTag,

	}

	

	local tagCategories = {}

	local function getTagCategories(info)

		for k in pairs(tagCategories) do tagCategories[k] = nil end

		

		for _, cat in pairs(ShadowUF.Tags.defaultCategories) do

			tagCategories[cat] = TAG_GROUPS[cat]

		end

		

		return tagCategories

	end

	

	-- Tag configuration

	options.args.tags = {

		type = "group",

		childGroups = "tab",

		name = L["Add tags"],

		desc = getPageDescription,

		hidden = hideAdvancedOption,

		args = {

			general = {

				order = 0,

				type = "group",

				name = L["Tag list"],

				args = {

					help = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Help"],

						hidden = function() return ShadowUF.db.profile.advanced end,

						args = {

							description = {

								order = 0,

								type = "description",

								name = L["You can add new custom tags through this page, if you're looking to change what tags are used in text look under the Text tab for an Units configuration."],

							},

						},

					},

					search = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Search"],

						args = {

							search = {

								order = 1,

								type = "input",

								name = L["Search tags"],

								set = function(info, text) tagData.search = text end,

								get = function(info) return tagData.search end,

							},

						},

					},

					list = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Tags"],

						args = {},

					},

				},

			},

			add = {

				order = 1,

				type = "group",

				name = L["Add new tag"],

				args = {

					help = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Help"],

						args = {

							help = {

								order = 0,

								type = "description",

								name = L["You can find more information on creating your own custom tags in the \"Help\" tab above."],

							},

						},

					},

					add = {

						order = 1,

						type = "group",

						inline = true,

						name = L["Add new tag"],

						args = {

							error = {

								order = 0,

								type = "description",

								name = function() return tagData.addError or "" end,

								hidden = function() return not tagData.addError end,

							},

							errorHeader = {

								order = 0.50,

								type = "header",

								name = "",

								hidden = function() return not tagData.addError end,

							},

							tag = {

								order = 1,

								type = "input",

								name = L["Tag name"],

								desc = L["Tag that you will use to access this code, do not wrap it in brackets or parenthesis it's automatically done. For example, you would enter \"foobar\" and then access it with [foobar]."],

								validate = function(info, text)

									if( text == "" ) then

										tagData.addError = L["You must enter a tag name."]

									elseif( string.match(text, "[%[%]%(%)]") ) then

										tagData.addError = string.format(L["You cannot name a tag \"%s\", tag names should contain no brackets or parenthesis."], text)

									elseif( ShadowUF.tagFunc[text] ) then

										tagData.addError = string.format(L["The tag \"%s\" already exists."], text)

									else

										tagData.addError = nil

									end

									

									AceRegistry:NotifyChange("ShadowedUF")

									return tagData.addError and "" or true

								end,

								set = function(info, tag)

									tagData.name = tag

									tagData.error = nil

									tagData.addError = nil

									

									ShadowUF.db.profile.tags[tag] = {func = "function(unit, unitOwner)\n\nend", category = "misc"}

									options.args.tags.args.general.args.list.args[tag] = tagTable

									Config.tagTextTable.args.misc.args[tag] = Config.tagTable

									

									selectDialogGroup("tags", "edit")

								end,

							},

						},

					},

				},

			},

			edit = {

				order = 2,

				type = "group",

				name = L["Edit tag"],

				hidden = function() return not tagData.name end,

				args = {

					help = {

						order = 0,

						type = "group",

						inline = true,

						name = L["Help"],

						args = {

							help = {

								order = 0,

								type = "description",

								name = L["You can find more information on creating your own custom tags in the \"Help\" tab above.|nSUF will attempt to automatically detect what events your tag will need, so you do not generally need to fill out the events field."],

							},

						},

					},

					tag = {

						order = 1,

						type = "group",

						inline = true,

						name = function() return string.format(L["Editing %s"], tagData.name or "") end,

						args = {

							error = {

								order = 0,

								type = "description",

								name = function()

									if( tagData.error ) then

										return "|cffff0000" .. tagData.error .. "|r"

									end

									return ""

								end,

								hidden = function() return not tagData.error end,

							},

							errorHeader = {

								order = 1,

								type = "header",

								name = "",

								hidden = function() return not tagData.error end,

							},

							discovery = {

								order = 1,

								type = "toggle",

								name = L["Disable event discovery"],

								desc = L["This will disable the automatic detection of what events this tag will need, you should leave this unchecked unless you know what you are doing."],

								set = function(info, value) tagData.discovery = value end,

								get = function() return tagData.discovery end,

								width = "full",

							},

							frequencyEnable = {

								order = 1.10,

								type = "toggle",

								name = L["Enable frequent updates"],

								desc = L["Flags the tag for frequent updating, it will update the tag on a timer regardless of any events firing."],

								set = function(info, value) 

									tagData.frequency = value and 5 or nil

									set(info, tagData.frequency, "frequency")

								end,

								get = function(info) return get(info, "frequency") ~= "" and true or false end,

								width = "full",

							},

							frequency = {

								order = 1.20,

								type = "input",

								name = L["Update interval"],

								desc = L["How many seconds between updates.|n[WARNING] By setting the frequency to 0 it will update every single frame redraw, if you want to disable frequent updating uncheck it don't set this to 0."],

								disabled = function(info) return get(info) == "" end,

								validate = function(info, value)

									value = tonumber(value)

									if( not value ) then

										tagData.error = L["Invalid interval entered, must be a number."]

									elseif( value < 0 ) then

										tagData.error = L["You must enter a number that is 0 or higher, negative numbers are not allowed."]

									else

										tagData.error = nil

									end

									

									if( tagData.error ) then

										AceRegistry:NotifyChange("ShadowedUF")

										return ""

									end

									

									return true

								end,

								set = function(info, value)

									tagData.frequency = tonumber(value)

									tagData.frequency = tagData.frequency < 0 and 0 or tagData.frequency

									

									set(info, tagData.frequency)

								end,

								get = function(info) return tostring(get(info) or "") end,

								width = "half",

							},

							name = {

								order = 2,

								type = "input",

								name = L["Tag name"],

								set = set,

								get = get,

							},

							category = {

								order = 2.5,

								type = "select",

								name = L["Category"],

								values = getTagCategories,

								set = set,

								get = get,

							},



							sep = {

								order = 2.75,

								type = "description",

								name = "",

								width = "full",

							},

							events = {

								order = 3,

								type = "input",

								name = L["Events"],

								desc = L["Events that should be used to trigger an update of this tag. Separate each event with a single space."],

								width = "full",

								validate = function(info, text)

									if( ShadowUF.Tags.defaultTags[tagData.name] ) then

										return true

									end



									if( text == "" or string.match(text, "[^_%a%s]") ) then

										tagData.error = L["You have to set the events to fire, you can only enter letters and underscores, \"FOO_BAR\" for example is valid, \"APPLE_5_ORANGE\" is not because it contains a number."]

										tagData.eventError = text

										AceRegistry:NotifyChange("ShadowedUF")

										return ""

									end

									

									tagData.eventError = text

									tagData.error = nil

									return true			

								end,

								set = set,

								get = function(info)

									if( tagData.eventError ) then

										return tagData.eventError

									end

									

									return get(info)

								end,

							},

							func = {

								order = 4,

								type = "input",

								multiline = true,

								name = L["Code"],

								desc = L["Your code must be wrapped in a function, for example, if you were to make a tag to return the units name you would do:|n|nfunction(unit, unitOwner)|nreturn UnitName(unitOwner)|nend"],

								width = "full",

								validate = function(info, text)

									if( ShadowUF.Tags.defaultTags[tagData.name] ) then

										return true

									end

									

									local funct, msg = loadstring("return " .. text)

									if( not string.match(text, "function") ) then

										tagData.error = L["You must wrap your code in a function."]

										tagData.funcError = text

									elseif( not funct and msg ) then

										tagData.error = string.format(L["Failed to save tag, error:|n %s"], msg)

										tagData.funcError = text

									else

										tagData.error = nil

										tagData.funcError = nil

									end

									

									AceRegistry:NotifyChange("ShadowedUF")

									return tagData.error and "" or true

								end,

								set = function(info, value)

									value = string.gsub(value, "||", "|")

									set(info, value)

									

									-- Try and automatically identify the events this tag is going to want to use

									if( not tagData.discovery ) then

										tagData.eventError = nil

										ShadowUF.db.profile.tags[tagData.name].events = ShadowUF.Tags:IdentifyEvents(value) or ""

									end

									

									ShadowUF.Tags:Reload(tagData.name)

								end,

								get = function(info)

									if( tagData.funcError ) then

										return stripCode(tagData.funcError)

									end

									return stripCode(ShadowUF.Tags.defaultTags[tagData.name] or ( ShadowUF.db.profile.tags[tagData.name] and ShadowUF.db.profile.tags[tagData.name].func))

								end,

							},

							delete = {

								order = 5,

								type = "execute",

								name = L["Delete"],

								hidden = function() return ShadowUF.Tags.defaultTags[tagData.name] end,

								confirm = true,

								confirmText = L["Are you sure you want to delete this tag?"],

								func = function(info)

									local category = ShadowUF.db.profile.tags[tagData.name].category

									if( category ) then

										Config.tagTextTable.args[category].args[tagData.name] = nil

									end

									

									options.args.tags.args.general.args.list.args[tagData.name] = nil

									

									ShadowUF.db.profile.tags[tagData.name] = nil

									ShadowUF.tagFunc[tagData.name] = nil

									ShadowUF.Tags:Reload(tagData.name)



									tagData.name = nil

									tagData.error = nil

									selectDialogGroup("tags", "general")

								end,

							},

						},

					},

				},

			},

			help = {

				order = 3,

				type = "group",

				name = L["Help"],

				args = {

					general = {

						order = 0,

						type = "group",

						name = L["General"],

						inline = true,

						args = {

							general = {

								order = 0,

								type = "description",

								name = L["See the documentation below for information and examples on creating tags, if you just want basic Lua or WoW API information then see the Programming in Lua and WoW Programming links."],

							},

						},

					},

					documentation = {

						order = 1,

						type = "group",

						name = L["Documentation"],

						inline = true,

						args = {

							doc = {

								order = 0,

								type = "input",

								name = L["Documentation"],

								set = false,

								get = function() return "http://wiki.github.com/Shadowed/ShadowedUnitFrames/tag-documentation" end,

								width = "full",

							},

						},

					},

					resources = {

						order = 2,

						type = "group",

						inline = true,

						name = L["Resources"],

						args = {

							lua = {

								order = 0,

								type = "input",

								name = L["Programming in Lua"],

								desc = L["This is a good guide on how to get started with programming in Lua, while you do not need to read the entire thing it is a helpful for understanding the basics of Lua syntax and API's."],

								set = false,

								get = function() return "http://www.lua.org/pil/" end,

								width = "full",

							},

							wow = {

								order = 1,

								type = "input",

								name = L["WoW Programming"],

								desc = L["WoW Programming is a good resource for finding out what difference API's do and how to call them."],

								set = false,

								get = function() return "http://wowprogramming.com/docs" end,

								width = "full",

							},

						},

					},

				},

			},

		},

	}

	

	-- Load the initial tag list

	for tag in pairs(ShadowUF.Tags.defaultTags) do

		options.args.tags.args.general.args.list.args[tag] = tagTable

	end

	

	for tag, data in pairs(ShadowUF.db.profile.tags) do

		options.args.tags.args.general.args.list.args[tag] = tagTable

	end

end



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

-- VISIBILITY OPTIONS

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

local function loadVisibilityOptions()

	-- As zone units are only enabled in a certain zone... it's pointless to provide visibility options for them

	local unitBlacklist = {}

	for unit in pairs(ShadowUF.Units.zoneUnits) do unitBlacklist[unit] = true end

	for unit, parent in pairs(ShadowUF.Units.childUnits) do

		if( ShadowUF.Units.zoneUnits[parent] ) then

			unitBlacklist[unit] = true

		end

	end

		

	local globalVisibility = {}

	local function set(info, value)

		local key = info[#(info)]

		local unit = info[#(info) - 1]

		local area = info[#(info) - 2]

		

		if( key == "enabled" ) then

			key = ""

		end

		

		if( value == nil ) then

			value = false

		elseif( value == false ) then

			value = nil

		end

		

		for _, configUnit in pairs(ShadowUF.unitList) do

			if( ( configUnit == unit or unit == "global" ) and not unitBlacklist[configUnit] ) then

				ShadowUF.db.profile.visibility[area][configUnit .. key] = value

			end

		end

		

		-- Annoying yes, but only way that works

		ShadowUF.Units:CheckPlayerZone(true)

		

		if( unit == "global" ) then

			globalVisibility[area .. key] = value

		end

	end

	

	local function get(info)

		local key = info[#(info)]

		local unit = info[#(info) - 1]

		local area = info[#(info) - 2]



		if( key == "enabled" ) then

			key = ""

		end



		if( unit == "global" ) then

			if( globalVisibility[area .. key] == false ) then

				return nil

			elseif( globalVisibility[area .. key] == nil ) then

				return false

			end

			

			return globalVisibility[area .. key]

		elseif( ShadowUF.db.profile.visibility[area][unit .. key] == false ) then

			return nil

		elseif( ShadowUF.db.profile.visibility[area][unit .. key] == nil ) then

			return false

		end

			

		return ShadowUF.db.profile.visibility[area][unit .. key]

	end

	

	local function getHelp(info)

		local unit = info[#(info) - 1]

		local area  = info[#(info) - 2]

		local key = info[#(info)]

		if( key == "enabled" ) then

			key = ""

		end

		

		local current

		if( unit == "global" ) then

			current = globalVisibility[area .. key]

		else

			current = ShadowUF.db.profile.visibility[area][unit .. key]

		end

		

		if( current == false ) then

			return string.format(L["Disabled in %s"], AREA_NAMES[area])

		elseif( current == true ) then

			return string.format(L["Enabled in %s"], AREA_NAMES[area])

		end



		return L["Using unit settings"]

	end

	

	local areaTable = {

		type = "group",

		order = function(info) return info[#(info)] == "none" and 2 or 1 end,

		childGroups = "tree",

		name = function(info)

			return AREA_NAMES[info[#(info)]]

		end,

		get = get,

		set = set,

		args = {},

	}

	

	Config.visibilityTable = {

		type = "group",

		order = function(info) return info[#(info)] == "global" and 1 or (getUnitOrder(info) + 1) end,

		name = function(info) return info[#(info)] == "global" and L["Global"] or getName(info) end,

		args = {

			help = {

				order = 0,

				type = "group",

				name = L["Help"],

				inline = true,

				hidden = hideBasicOption,

				args = {

					help = {

						order = 0,

						type = "description",

						name = function(info)

							return string.format(L["Disabling a module on this page disables it while inside %s. Do not disable a module here if you do not want this to happen!."], string.lower(AREA_NAMES[info[2]]))

						end,

					},		

				}, 	

			},

			enabled = {

				order = 0.25,

				type = "toggle",

				name = function(info)

					local unit = info[#(info) - 1]

					if( unit == "global" ) then return "" end

					return string.format(L["%s frames"], L.units[unit])

				end,

				hidden = function(info) return info[#(info) - 1] == "global" end,

				desc = getHelp,

				tristate = true,

				width = "double",

			},

			sep = {

				order = 0.5,

				type = "description",

				name = "",

				width = "full",

				hidden = function(info) return info[#(info) - 1] == "global" end,

			},

		}

	}

	

	local moduleTable = {

		order = 1,

		type = "toggle",

		name = getName,

		desc = getHelp,

		tristate = true,

		hidden = function(info)

			if( info[#(info) - 1] == "global" ) then return false end

			return hideRestrictedOption(info)

		end,

		arg = 1,

	}

		

	for key, module in pairs(ShadowUF.modules) do

		if( module.moduleName ) then

			Config.visibilityTable.args[key] = moduleTable

		end

	end

	

	areaTable.args.global = Config.visibilityTable

	for _, unit in pairs(ShadowUF.unitList) do

		if( not unitBlacklist[unit] ) then

			areaTable.args[unit] = Config.visibilityTable

		end

	end

	

	options.args.visibility = {

		type = "group",

		childGroups = "tab",

		name = L["Zone configuration"],

		desc = getPageDescription,

		args = {

			start = {

				order = 0,

				type = "group",

				name = L["Help"],

				inline = true,

				hidden = hideBasicOption,

				args = {

					help = {

						order = 0,

						type = "description",

						name = L["Gold checkmark - Enabled in this zone / Grey checkmark - Disabled in this zone / No checkmark - Use the default unit settings"],

					},

				},

			},

			pvp = areaTable,

			arena = areaTable,

			party = areaTable,

			raid = areaTable,

		},

	}

end



local function loadOptions()

	options = {

		type = "group",

		name = "Shadowed UF",

		args = {}

	}



	loadGeneralOptions()

	loadUnitOptions()

	loadHideOptions()

	loadTagOptions()

	loadFilterOptions()

	loadVisibilityOptions()	

	

	-- Ordering

	options.args.general.order = 1

	options.args.enableUnits.order = 2

	options.args.units.order = 3

	options.args.filter.order = 4

	options.args.hideBlizzard.order = 5

	options.args.visibility.order = 6

	options.args.tags.order = 7

	

	-- So modules can access it easier/debug

	Config.options = options

	

	-- Options finished loading, fire callback for any non-default modules that want to be included

	ShadowUF:FireModuleEvent("OnConfigurationLoad")

end



function Config:Open()

	AceDialog = AceDialog or LibStub("AceConfigDialog-3.0")

	AceRegistry = AceRegistry or LibStub("AceConfigRegistry-3.0")

	

	if( not registered ) then

		loadOptions()

		

		LibStub("AceConfig-3.0"):RegisterOptionsTable("ShadowedUF", options)

		AceDialog:SetDefaultSize("ShadowedUF", 845, 550)

		registered = true

	end

	

	AceDialog:Open("ShadowedUF")

end