-- Remove invalid custom cooldowns
for k,v in pairs(self.db.global.cooldowns) do
	if (not GetSpellInfo(k)) then
		self.db.global.cooldowns[k] = nil
	end
end

-- Populate cooldowns with spell names and icons
for spellId,_ in pairs(self.cooldowns) do
	local name, _, icon = GetSpellInfo(spellId)
	self.cooldowns[spellId].icon = self.cooldowns[spellId].icon or icon
	self.cooldowns[spellId].name = name
end

self:SetupOptions()

wipe(self.spellCasts)

self.index = 1

for i = #self.bars, 1, -1 do
	self:Delete(self.bars[i].key, true)
	table.remove(self.bars, i)
end

for key,_ in pairs(self.db.profile.bars) do
	self:Initialize(key)
	self.index = self.index + 1
end

-- Create a default bar if none exist
if self.index == 1 then
	self:Initialize("OmniBar1", "OmniBar")
	self.index = 2
end

for key,_ in pairs(self.db.profile.bars) do
	self:AddBarToOptions(key)
end

self:Refresh(true)

for _,v in pairs({"class", "charges", "parent", "name", "icon"}) do
	if cooldown[v] then
		copy[v] = cooldown[v]
	end
end

if cooldown.duration then
	if type(cooldown.duration) == "table" then
		copy.duration = {}
		for k, v in pairs(cooldown.duration) do
			copy.duration[k] = v
		end
	else
		copy.duration = { default = cooldown.duration }
	end
end

if cooldown.specID then
	copy.specID = {}
	for i = 1, #cooldown.specID do
		table.insert(copy.specID, cooldown.specID[i])
	end
end

return copy

-- Add custom spells
for k,v in pairs(self.db.global.cooldowns) do
	local name, _, icon = GetSpellInfo(k)
	if name then
		-- Backup if we are going to override
		if addon.Cooldowns[k] and (not addon.Cooldowns[k].custom) and (not self.BackupCooldowns[k]) then
			self.BackupCooldowns[k] = self:CopyCooldown(addon.Cooldowns[k])
		end
		addon.Cooldowns[k] = v
		addon.Cooldowns[k].icon = addon.Cooldowns[k].icon or icon
		addon.Cooldowns[k].name = name
		if SPELL_ID_BY_NAME then SPELL_ID_BY_NAME[name] = k end
	else
		self.db.global.cooldowns[k] = nil
	end
end

-- force adaptive in arena since enemies are finite and known
if self.zone == "arena" then return true end

-- everything but all enemies are known, so force adaptive
if self.settings.trackUnit ~= "ENEMY" then return true end

-- if GetZonePVPInfo() == "sanctuary" then return end

OmniBar_AddIcon(self, self.spellCasts[name][spellID])

self:AddCustomSpells()

local f = _G[key] or CreateFrame("Frame", key, UIParent, "OmniBarTemplate")
f:Show()
f.settings = self.db.profile.bars[key]
f.settings.align = f.settings.align or "CENTER"
f.settings.maxIcons = f.settings.maxIcons or DEFAULTS.maxIcons
f.key = key
f.icons = {}
f.active = {}
f.detected = {}
f.spellCasts = self.spellCasts
f.specs = self.specs
f.BASE_ICON_SIZE = BASE_ICON_SIZE
f.numIcons = 0
f:RegisterForDrag("LeftButton")

f.anchor.text:SetText(f.settings.name)

-- Upgrade units
f.settings.units = nil
if (not f.settings.trackUnit) then f.settings.trackUnit = "ENEMY" end

-- Remove invalid spells
if f.settings.spells then
	for k,_ in pairs(f.settings.spells) do
		if (not addon.Cooldowns[k]) or addon.Cooldowns[k].parent then f.settings.spells[k] = nil end
	end
end

f.adaptive = OmniBar_IsAdaptive(f)

-- Upgrade custom spells
for k,v in pairs(f.settings) do
	local spellID = tonumber(k:match("^spell(%d+)"))
	if spellID then
		if (not f.settings.spells) then
			f.settings.spells = {}
			if (not f.settings.noDefault) then
				for k,v in pairs(addon.Cooldowns) do
					if v.default then f.settings.spells[k] = true end
				end
			end
		end
		f.settings.spells[spellID] = v
		f.settings[k] = nil
	end
end
f.settings.noDefault = nil

-- Load the settings
OmniBar_LoadSettings(f)

-- Create the icons
for spellID,_ in pairs(addon.Cooldowns) do
	if OmniBar_IsSpellEnabled(f, spellID) then
		OmniBar_CreateIcon(f)
	end
end

-- Create the duplicate icons
for i = 1, MAX_DUPLICATE_ICONS do
	OmniBar_CreateIcon(f)
end

OmniBar_ShowAnchor(f)
OmniBar_ResetIcons(f)
OmniBar_UpdateIcons(f)
OmniBar_Center(f)

f.OnEvent = OmniBar_OnEvent

f:RegisterEvent("PLAYER_ENTERING_WORLD", "OnEvent")
f:RegisterEvent("ZONE_CHANGED_NEW_AREA", "OnEvent")
f:RegisterEvent("PLAYER_TARGET_CHANGED", "OnEvent")
f:RegisterEvent("PLAYER_REGEN_DISABLED", "OnEvent")
f:RegisterEvent("GROUP_ROSTER_UPDATE", "OnEvent")

if WOW_PROJECT_ID ~= WOW_PROJECT_CLASSIC then
	f:RegisterEvent("PLAYER_FOCUS_CHANGED", "OnEvent")
	f:RegisterEvent("ARENA_OPPONENT_UPDATE", "OnEvent")
end

if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
	f:RegisterEvent("ARENA_PREP_OPPONENT_SPECIALIZATIONS", "OnEvent")
	f:RegisterEvent("UPDATE_BATTLEFIELD_STATUS", "OnEvent")
end

f:RegisterEvent("UPDATE_BATTLEFIELD_SCORE", "OnEvent")

table.insert(self.bars, f)

-- Set dim
icon:SetAlpha(self.settings.unusedAlpha and
	icon.cooldown:GetCooldownTimes() == 0 and
	(not border) and
	self.settings.unusedAlpha or 1)

self.zone = zone
self.rated = IsRatedBattleground and IsRatedBattleground()
self.disabled = (zone == "arena" and (not self.settings.arena)) or
	(self.rated and (not self.settings.ratedBattleground)) or
	(zone == "pvp" and (not self.settings.battleground) and (not self.rated)) or
	(zone == "scenario" and (not self.settings.scenario)) or
	(zone ~= "arena" and zone ~= "pvp" and zone ~= "scenario" and (not self.settings.world))

self.adaptive = OmniBar_IsAdaptive(self)

if refresh or disabled ~= self.disabled then
	OmniBar_LoadPosition(self)
	OmniBar_ResetIcons(self)
	OmniBar_UpdateIcons(self)
	OmniBar_ShowAnchor(self)
	if zone == "arena" and (not self.disabled) then
		wipe(self.detected)
		wipe(self.specs)
		wipe(self.spellCasts)
		OmniBar_OnEvent(self, "ARENA_OPPONENT_UPDATE")
	end
end

-- unset unknown sourceName
sourceName = sourceName == COMBATLOG_FILTER_STRING_UNKNOWN_UNITS and nil or sourceName

-- if it's a pet associate with owner
local ownerName = UnitOwnerName(sourceGUID)
local name = ownerName or sourceName

if (not name) then return end

if addon.Resets[spellID] and self.spellCasts[name] and event == "SPELL_CAST_SUCCESS" then
	for i = 1, #addon.Resets[spellID] do
		local reset = addon.Resets[spellID][i]
		if type(reset) == "table" and reset.amount then
			if self.spellCasts[name][reset.spellID] then
				self.spellCasts[name][reset.spellID].duration = self.spellCasts[name][reset.spellID].duration - reset.amount
				if self.spellCasts[name][reset.spellID].duration < 1 then
					self.spellCasts[name][reset.spellID] = nil
				end
			end
		else
			if type(reset) == "table" then reset = reset.spellID end
			self.spellCasts[name][reset] = nil
		end
	end
	self:SendMessage("OmniBar_ResetSpellCast", name, spellID)
end

if (not addon.Cooldowns[spellID]) then return end

local now = GetTime()

-- make sure we aren't adding a duplicate
if self.spellCasts[name] and self.spellCasts[name][spellID] and self.spellCasts[name][spellID].timestamp == now then
	return
end

-- only track players and their pets
if (not ownerName) and bit_band(sourceFlags, COMBATLOG_OBJECT_TYPE_PLAYER) == 0 then return end

local duration = GetCooldownDuration(addon.Cooldowns[spellID])
local charges = addon.Cooldowns[spellID].charges

-- make sure spellID is parent
spellID = addon.Cooldowns[spellID].parent or spellID

-- child doesn't have custom charges, use parent
if (not charges) then
	charges = addon.Cooldowns[spellID].charges
end

-- child doesn't have a custom duration, use parent
if (not duration) then
	duration = GetCooldownDuration(addon.Cooldowns[spellID])
end

self.spellCasts[name] = self.spellCasts[name] or {}
self.spellCasts[name][spellID] = {
	charges = charges,
	duration = duration,
	event = event,
	expires = now + duration,
	ownerName = ownerName,
	sourceFlags = sourceFlags,
	sourceGUID = sourceGUID,
	sourceName = sourceName,
	spellID = spellID,
	spellName = GetSpellInfo(spellID),
	timestamp = now,
}
self:SendMessage("OmniBar_SpellCast", name, spellID)

local sourceFlags = 0

if UnitReaction("player", unit) < 4 then
	sourceFlags = sourceFlags + COMBATLOG_OBJECT_REACTION_HOSTILE
end

if UnitIsPlayer(unit) then
	sourceFlags = sourceFlags + COMBATLOG_OBJECT_TYPE_PLAYER
end

self:AddSpellCast(event, UnitGUID(unit), GetUnitName(unit, true), sourceFlags, spellID)

elseif event == "ZONE_CHANGED_NEW_AREA" then
	OmniBar_SetZone(self, true)

elseif event == "UPDATE_BATTLEFIELD_STATUS" then -- IsRatedBattleground() doesn't return valid response until this event
	if self.disabled or self.zone ~= "pvp" then return end
	if (not self.rated) and IsRatedBattleground() then OmniBar_SetZone(self) end

elseif event == "UPDATE_BATTLEFIELD_SCORE" then
	for i = 1, GetNumBattlefieldScores() do
		local name, _,_,_,_,_,_,_, classToken, _,_,_,_,_,_, talentSpec = GetBattlefieldScore(i)
		if name and SPEC_ID_BY_NAME[classToken] and SPEC_ID_BY_NAME[classToken][talentSpec] then
			if (not self.specs[name]) then
				self.specs[name] = SPEC_ID_BY_NAME[classToken][talentSpec]
				self:SendMessage("OmniBar_SpecUpdated", name)
			end
		end
	end

elseif event == "ARENA_PREP_OPPONENT_SPECIALIZATIONS" then
	if WOW_PROJECT_ID ~= WOW_PROJECT_MAINLINE then return end
	if self.disabled or (not self.adaptive) or (not self.settings.showUnused) then return end
	for i = 1, MAX_ARENA_SIZE do
		if self.settings.trackUnit == "ENEMY" or self.settings.trackUnit == "arena" .. i then
			local specID = GetArenaOpponentSpec(i)
			if specID and specID > 0 and (not self.detected[i]) then
				local _,_,_,_,_, class = GetSpecializationInfoByID(specID)
				if class then
					self.detected[i] = class
					OmniBar_AddIconsByClass(self, class, i, specID)
				end
			end
		end
	end

elseif event == "ARENA_OPPONENT_UPDATE" then
	if self.disabled or (not self.settings.showUnused) then return end

	-- we get the info from ARENA_PREP_OPPONENT_SPECIALIZATIONS on retail
	if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
		OmniBar_OnEvent(self, "ARENA_PREP_OPPONENT_SPECIALIZATIONS")
		return
	end

	local unit = ...

	if (not unit) or (not UnitIsPlayer(unit)) then return end

	if unit == self.settings.trackUnit then
		OmniBar_Refresh(self)
		return
	end

	if self.settings.trackUnit == "ENEMY" then
		local _, class = UnitClass(unit)
		if class then
			local i = tonumber(unit:match("%d+$"))
			if (not self.detected[i]) then
				self.detected[i] = class
				OmniBar_AddIconsByClass(self, class, i)
			end
		end
	end

elseif event == "GROUP_ROSTER_UPDATE" then
	if self.disabled then return end
	if self.settings.trackUnit == "GROUP" or self.settings.trackUnit:match("^party") then
		OmniBar_Refresh(self)
	end

elseif event == "PLAYER_TARGET_CHANGED" or event == "PLAYER_FOCUS_CHANGED" or event == "PLAYER_REGEN_DISABLED" then
	if self.disabled then return end

	local unit = (event == "PLAYER_TARGET_CHANGED" and "target") or (event == "PLAYER_FOCUS_CHANGED" and "focus")
	if unit and unit:upper() == self.settings.trackUnit then
		OmniBar_Refresh(self)
	end

	-- update icon borders
	OmniBar_UpdateAllBorders(self)

	-- we don't need to add in arena
	if self.zone == "arena" then return end

	-- only add to bars tracking all enemies
	if self.settings.trackUnit ~= "ENEMY" then return end

	-- only add icons if show adaptive is checked
	if (not self.settings.showUnused) or
		(not self.adaptive) or
		(not UnitIsHostile("target"))
	then
		return
	end

	-- only add icons when we're in combat
	-- if event == "PLAYER_TARGET_CHANGED" and (not InCombatLockdown()) then return end

	local guid = UnitGUID("target")
	local _, class = UnitClass("target")
	if class and UnitIsPlayer("target") then
		if self.detected[guid] then return end
		self.detected[guid] = class
		OmniBar_AddIconsByClass(self, class, nil, self.specs[GetUnitName("target", true)])
	end
end

-- Set the scale
self.container:SetScale(self.settings.size/BASE_ICON_SIZE)

OmniBar_LoadPosition(self)
OmniBar_ResetIcons(self)
OmniBar_UpdateIcons(self)
OmniBar_Center(self)

if (not self.settings.position) then
	self.settings.position = {}
end
self.settings.position.point = point
self.settings.position.relativeTo = relativeTo
self.settings.position.relativePoint = relativePoint
self.settings.position.xOfs = xOfs
self.settings.position.yOfs = yOfs
self.settings.position.frameStrata = frameStrata

if (not self.settings.spells) then return addon.Cooldowns[spellID].default end

return self.settings.spells[spellID]

local guid = info.sourceGUID
if guid == nil then return end

local name = info.ownerName or info.sourceName

local isHostile = IsSourceHostile(info.sourceFlags)

if self.settings.trackUnit == "ENEMY" and isHostile then
	return true
end

local isPlayer = UnitIsUnit("player", name)

if self.settings.trackUnit == "PLAYER" and isPlayer then
	return true
end

if self.settings.trackUnit == "TARGET" and (UnitGUID("target") == guid or GetUnitName("target", true) == name) then
	return true
end

if self.settings.trackUnit == "FOCUS" and (UnitGUID("focus") == guid or GetUnitName("focus", true) == name) then
	return true
end

if self.settings.trackUnit == "GROUP" and (not isPlayer) and (UnitInParty(name) or UnitInRaid(name)) then
	return true
end

for i = 1, MAX_ARENA_SIZE do
	local unit = "arena" .. i
	if (i == guid or UnitGUID(unit) == guid) and self.settings.trackUnit == unit:lower() then
		return true
	end
end

for i = 1, 4 do
	local unit = "party" .. i
	if (i == guid or UnitGUID(unit) == guid) and self.settings.trackUnit == unit:lower() then
		return true
	end
end

local bar = icon:GetParent():GetParent()

OmniBar_StopAnimation(self, icon)

if (not bar.settings.showUnused) then
	icon:Hide()
else
	if icon.TargetTexture:GetAlpha() == 0 and
		icon.FocusTexture:GetAlpha() == 0 and
		bar.settings.unusedAlpha then
			icon:SetAlpha(bar.settings.unusedAlpha)
	end
end
bar:StopMovingOrSizing()
OmniBar_Position(bar)

local now = GetTime()

for name,_ in pairs(self.spellCasts) do
	for k,v in pairs(self.spellCasts[name]) do
		if now >= v.expires then
			self.spellCasts[name][k] = nil
		else
			OmniBar_AddIcon(self, self.spellCasts[name][k])
		end
	end
end

if self.disabled then return end

if self.settings.showUnused then
	if self.settings.trackUnit == "ENEMY" then
		if (not self.adaptive) then
			for spellID,_ in pairs(addon.Cooldowns) do
				if OmniBar_IsSpellEnabled(self, spellID) then
					OmniBar_AddIcon(self, { spellID = spellID })
				end
			end
		end
	elseif self.settings.trackUnit == "GROUP" then
		for i = 1, GetNumGroupMembers() do
			local name, _,_,_,_, class = GetRaidRosterInfo(i)
			local guid = UnitGUID(name)
			if class and (not UnitIsUnit("player", name)) then
				OmniBar_AddIconsByClass(self, class, UnitGUID(name), self.specs[name])
			end
		end
	else
		local class, specID = OmniBar_UnitClassAndSpec(self)
		if class and UnitIsPlayer(self.settings.trackUnit) then
			OmniBar_AddIconsByClass(self, class, nil, specID)
		end
	end
end

OmniBar_Position(self)

local icon, duplicate

-- Try to reuse a visible frame
for i = 1, #self.active do
	if self.active[i].spellID == info.spellID then
		duplicate = true
		-- check if we can use this icon, but not when initializing arena opponents
		if info.timestamp or self.zone ~= "arena" then
			-- use icon if not bound to a sourceGUID
			if (not self.active[i].sourceGUID) then
				duplicate = nil
				icon = self.active[i]
				break
			end

			-- if it's the same source, reuse the icon
			if info.sourceGUID and IconIsUnit(self.active[i].sourceGUID, info.sourceGUID) then
				duplicate = nil
				icon = self.active[i]
				break
			end

		end
	end
end

-- We couldn't find a visible frame to reuse, try to find an unused
if (not icon) then
	if #self.active >= self.settings.maxIcons then return end
	if (not self.settings.multiple) and duplicate then return end
	for i = 1, #self.icons do
		if (not self.icons[i]:IsVisible()) then
			icon = self.icons[i]
			icon.specID = nil
			break
		end
	end
end

-- We couldn't find a frame to use
if (not icon) then return end

icon.class = addon.Cooldowns[info.spellID].class
icon.sourceGUID = info.sourceGUID
icon.sourceName = info.ownerName or info.sourceName
icon.specID = info.specID and info.specID or self.specs[icon.sourceName]
icon.icon:SetTexture(addon.Cooldowns[info.spellID].icon)
icon.spellID = info.spellID
icon.timestamp = info.test and GetTime() or info.timestamp
icon.duration = info.test and math.random(5,30) or info.duration
icon.added = GetTime()

if icon.charges and info.charges and icon:IsVisible() then
	local start, duration = icon.cooldown:GetCooldownTimes()
	if icon.cooldown.finish and icon.cooldown.finish - GetTime() > 1 then
		-- add a charge
		local charges = icon.charges + 1
		icon.charges = charges
		icon.Count:SetText(charges)
		OmniBar_StartAnimation(self, icon)
		return icon
	end
elseif info.charges then
	icon.charges = 1
	icon.Count:SetText("1")
else
	icon.charges = nil
	icon.Count:SetText(nil)
end

if self.settings.names then
	local name = info.test and "Name" or icon.sourceName
	icon.Name:SetText(name)
end

-- Masque
if Masque then
	icon.MasqueGroup = Masque:Group("OmniBar", info.spellName)
	icon.MasqueGroup:AddButton(icon, {
		FloatingBG = false,
		Icon = icon.icon,
		Cooldown = icon.cooldown,
		Flash = false,
		Pushed = false,
		Normal = icon:GetNormalTexture(),
		Disabled = false,
		Checked = false,
		Border = _G[icon:GetName().."Border"],
		AutoCastable = false,
		Highlight = false,
		Hotkey = false,
		Count = false,
		Name = false,
		Duration = false,
		AutoCast = false,
	})
end

icon:Show()

if (icon.timestamp) then
	OmniBar_StartCooldown(self, icon, icon.timestamp)
	if (GetTime() == icon.timestamp) then OmniBar_StartAnimation(self, icon) end
end

return icon

	-- Set swipe alpha
	self.icons[i].cooldown:SetSwipeColor(0, 0, 0, self.settings.swipeAlpha or 0.65)

	-- Set border
	if self.settings.border then
		self.icons[i].icon:SetTexCoord(0, 0, 0, 1, 1, 0, 1, 1)
	else
		self.icons[i].icon:SetTexCoord(0.07, 0.9, 0.07, 0.9)
	end

	-- Set dim
	self.icons[i]:SetAlpha(self.settings.unusedAlpha and self.icons[i].cooldown:GetCooldownTimes() == 0 and
		self.settings.unusedAlpha or 1)

	-- Masque
	if self.icons[i].MasqueGroup then self.icons[i].MasqueGroup:ReSkin() end

end

-- Keep cooldowns together by class
if self.settings.showUnused then
	table.sort(self.active, function(a, b)
		local x, y = a.ownerName or a.sourceName or "", b.ownerName or b.sourceName or ""
		local aClass, bClass = a.class or 0, b.class or 0
		if aClass == bClass then
			-- if we are tracking a single unit we don't need to sort by name
			if self.settings.trackUnit ~= "ENEMY" and self.settings.trackUnit ~= "GROUP" then
				return a.spellID < b.spellID
			end
			if x < y then return true end
			if x == y then return a.spellID < b.spellID end
		end
		return CLASS_ORDER[aClass] < CLASS_ORDER[bClass]
	end)
else
	-- if we aren't showing unused, just sort by added time
	table.sort(self.active, function(a, b) return a.added == b.added and a.spellID < b.spellID or a.added < b.added end)
end

local count, rows = 0, 1
local grow = self.settings.growUpward and 1 or -1
local padding = self.settings.padding and self.settings.padding or 0
for i = 1, numActive do
	if self.settings.locked then
		self.active[i]:EnableMouse(false)
	else
		self.active[i]:EnableMouse(true)
	end
	self.active[i]:ClearAllPoints()
	local columns = self.settings.columns and self.settings.columns > 0 and self.settings.columns < numActive and
		self.settings.columns or numActive
	if i > 1 then
		count = count + 1
		if count >= columns then
			if self.settings.align == "CENTER" then
				self.active[i]:SetPoint("CENTER", self.anchor, "CENTER", (-BASE_ICON_SIZE-padding)*(columns-1)/2, (BASE_ICON_SIZE+padding)*rows*grow)
			else
				self.active[i]:SetPoint(self.settings.align, self.anchor, self.settings.align, 0, (BASE_ICON_SIZE+padding)*rows*grow)
			end

			count = 0
			rows = rows + 1
		else
			if self.settings.align == "RIGHT" then
				self.active[i]:SetPoint("TOPRIGHT", self.active[i-1], "TOPLEFT", -1 * padding, 0)
			else
				self.active[i]:SetPoint("TOPLEFT", self.active[i-1], "TOPRIGHT", padding, 0)
			end
		end

	else
		if self.settings.align == "CENTER" then
			self.active[i]:SetPoint("CENTER", self.anchor, "CENTER", (-BASE_ICON_SIZE-padding)*(columns-1)/2, 0)
		else
			self.active[i]:SetPoint(self.settings.align, self.anchor, self.settings.align, 0, 0)
		end
	end
end
OmniBar_ShowAnchor(self)