--[[--
Daybreak.
Add custom spell activation overlay and paladin holy power bar.
@script daybreak
]]

--[[--
Spell activation overlay.
Custom general purpose spell activation overlay.
@section overlay
]]

--[[--
Access constant default indicator size pixels.
@function getDefaultButtonSize
@treturn number positive integer
]]
local function getDefaultButtonSize()
	return 28
end

--[[--
Process timer tick to update remaining aura duration.
The update employs artificial delay to hopefully reduce the memory cost of updates.
@function applyOverlayUpdate
@tparam frame button button to update
@return nothing
]]
local function applyOverlayUpdate(button)
	assert (button ~= nil)

	local auraName = button.spell
	assert (auraName ~= nil)
	assert ('string' == type(auraName))
	assert (string.len(auraName) >= 2)
	assert (string.len(auraName) <= 256)

	local unitDesignation = button.unit
	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)

	local filter = button.filter or 'HELPFUL'
	local _, _, _, quantity, _, duration, expirationInstance = UnitAura(unitDesignation, auraName, nil, filter)
	quantity = quantity or 0
	assert (quantity ~= nil)
	assert ('number' == type(quantity))
	quantity = math.ceil(math.min(math.max(0, quantity), 99))

	if nil == expirationInstance then
		return
	end
	local now = GetTime()
	local remainingDuration = math.max(0, math.ceil(expirationInstance - now))
	local isDurationUnlimited = (remainingDuration or 0) == 0 and (duration or 0) == 0
	local t
	if isDurationUnlimited or remainingDuration > 60 then
		t = nil
	elseif quantity < 2 then
		t = tostring(remainingDuration)
	elseif quantity > 9 then
		t = tostring(remainingDuration) .. "*?"
	else
		t = tostring(remainingDuration) .. "*" .. tostring(quantity)
	end
	button:SetText(t)
end

local function overlayUpdateProcessor(self, updateDurationSec)
	assert (self ~= nil)

	assert (updateDurationSec ~= nil)
	assert ('number' == type(updateDurationSec))
	updateDurationSec = math.max(0, updateDurationSec)

	local updateCooldownDurationSec = self.updateCooldownDurationSec
	if nil == updateCooldownDurationSec then
		updateCooldownDurationSec = 0
	end
	assert (updateCooldownDurationSec ~= nil)
	assert ('number' == type(updateCooldownDurationSec))
	updateCooldownDurationSec = math.max(0, updateCooldownDurationSec)
	updateCooldownDurationSec = updateCooldownDurationSec - updateDurationSec

	if updateCooldownDurationSec > 0 then
		self.updateCooldownDurationSec = updateCooldownDurationSec
		return
	else
		updateCooldownDurationSec = 0.084
		self.updateCooldownDurationSec = updateCooldownDurationSec
		applyOverlayUpdate(self)
	end
end

--[[--
Process reaction to UNIT_AURA event for aura indicator.
When aura disappears from the unit associated with this button,
hide the button. Show it otherwise.
@function acceptOverlayUnitAura
@tparam button frame this button frame to update
@tparam string eventCategory given event category designation
@return nothing
]]
local function acceptOverlayUnitAura(button, eventCategory)
	assert (button ~= nil)
	assert (eventCategory ~= nil)
	assert ('string' == type(eventCategory))
	assert (string.len(eventCategory) >= 2)
	assert (string.len(eventCategory) <= 256)

	local auraName = button.spell
	assert (auraName ~= nil)
	assert ('string' == type(auraName))
	assert (string.len(auraName) >= 2)
	assert (string.len(auraName) <= 256)

	local unitDesignation = button.unit
	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)

	local filter = button.filter or 'HELPFUL'
	local name, _, icon = UnitAura(unitDesignation, auraName, nil, filter)
	if name then
		--[[ FIXME Apply graphics only once instead of every aura update ]]--
		button:SetNormalTexture(icon)
		button:Show()
		button:SetScript('OnUpdate', overlayUpdateProcessor)
	else
		button:Hide()
		button:SetScript('OnUpdate', nil)
	end
end

--[[--
Allocate button frame that represents a single aura
New button has two custom fields: unit and spell.
that is potentially applied to the player character.
The order of parameters allows for predictable
code line sorting.
@function createButton
@tparam number column horizontal position
@tparam number row vertical position
@tparam string localizedSpellName aura name to track
@tparam string buttonName
@tparam frame parentFrame
@treturn frame newly allocated button frame instance
]]
local function createButton(column, row, localizedSpellName, buttonName, parentFrame, filter)
	assert (buttonName ~= nil)
	assert ('string' == type(buttonName))
	assert (string.len(buttonName) >= 2)
	assert (string.len(buttonName) <= 256)

	assert (parentFrame ~= nil)

	assert (localizedSpellName ~= nil)
	assert ('string' == type(localizedSpellName))
	assert (string.len(localizedSpellName) >= 2)
	assert (string.len(localizedSpellName) <= 256)

	local button = CreateFrame('BUTTON', buttonName, parentFrame)
	local padding = 4
	local size = getDefaultButtonSize()
	local s = size + padding
	button:SetSize(size, size)
	button:SetPoint('BOTTOMLEFT', column * s, row * s)

	local text = button:CreateFontString(button:GetName() .. 'Text', 'OVERLAY')
	local fontHandle = DaybreakFont or NumberFont_Outline_Large
	text:SetFontObject(fontHandle)
	text:SetPoint('TOPRIGHT', button, 'TOPRIGHT', 16, 16)
	text:SetPoint('BOTTOMLEfT', button, 'BOTTOMLEFT', -16, -16)

	button:SetFontString(text)
	button:SetText(nil)

	button.spell = localizedSpellName
	button.unit = 'player'
	button.filter = filter or 'HELPFUL'

	button:RegisterEvent('UNIT_AURA')
	button:SetScript('OnEvent', acceptOverlayUnitAura)

	button:Hide()

	return button
end

--[[--
Plyer role assignment.
Assign player role in battlegrounds automatically.
@section role
]]

local function getEstimatedBattlegroundRole(unitDesignation)
	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)


	--[[ TODO Add complex rolecheck cases for Death Knight and Druid ]]--
	local roleDesignation = 'NONE'
	local _, classDesignation = UnitClass(unitDesignation)
	local i = GetPrimaryTalentTree()
	if 'MAGE' == classDesignation then
		roleDesignation = 'DAMAGER'
	elseif 'HUNTER' == classDesignation then
		roleDesignation = 'DAMAGER'
	elseif 'PALADIN' == classDesignation then
		if 1 == i then
			roleDesignation = 'HEALER'
		elseif 2 == i then
			roleDesignation = 'TANK'
		elseif 3 == i then
			roleDesignation = 'DAMAGER'
		end
	elseif 'PRIEST' == classDesignation then
		if 1 == i then
			roleDesignation = 'HEALER'
		elseif 2 == i then
			roleDesignation = 'HEALER'
		elseif 3 == i then
			roleDesignation = 'DAMAGER'
		end
	elseif 'WARRIOR' == classDesignation then
		if 1 == i then
			roleDesignation = 'DAMAGER'
		elseif 2 == i then
			roleDesignation = 'DAMAGER'
		elseif 3 == i then
			roleDesignation = 'TANK'
		end
	elseif 'WARLOCK' == classDesignation then
		roleDesignation = 'DAMAGER'
	end

	assert (roleDesignation ~= nil)
	assert ('string' == type(roleDesignation))
	assert (string.len(roleDesignation) >= 2)
	assert (string.len(roleDesignation) <= 256)
	return roleDesignation
end


local function roleFrameEventProcessor()
	local unitDesignation = 'player'
	local roleDesignation = getEstimatedBattlegroundRole(unitDesignation)
	UnitSetRole(unitDesignation, roleDesignation)
end

local function initRole(rootFrame)
	assert (rootFrame ~= nil)

	local roleFrame = CreateFrame('FRAME', 'DaybreakRoleFrame', rootFrame)
	roleFrame:SetScript('OnEvent', roleFrameEventProcessor)
	roleFrame:RegisterEvent('PLAYER_ENTERING_BATTLEGROUND')
	roleFrame:RegisterEvent('PLAYER_TALENT_UPDATE')
	roleFrame:RegisterEvent('ZONE_CHANGED_NEW_AREA')

	return roleFrame
end

--[[--
Paladin power bar.
Custom power bar to track paladin holy power resource.
@section powerbar
]]

local function getIndicatorTable(holyPowerIndicatorFrame)
	assert (holyPowerIndicatorFrame ~= nil)

	local t = holyPowerIndicatorFrame.children
	assert (t ~= nil)
	assert ('table' == type(t))
	assert (#t >= 1)
	assert (#t <= 256)

	return t
end

--[[--
Access constant default indicator color.
@function getHolyPowerIndicatorColor
@return red green blue
]]
local function getHolyPowerIndicatorColor()
	return 153 / 255, 0 / 255, 102 / 255
end

--[[--
Access constant default indicator color when out of combat.
@function getHolyPowerIndicatorColor
@return red green blue
]]
local function getHolyPowerIndicatorDecayColor()
	return 102 / 255, 51 / 255, 102 / 255
end

--[[--
Access unit designation that this holy power indicator is associated with.
@function getHolyPowerIndicatorUnitDesignation
@tparam self this holy power indicator frame
@treturn string unit designation
]]
local function getHolyPowerIndicatorUnitDesignation(self)
	assert (self ~= nil)

	local unitDesignation = self.unit
	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)

	return unitDesignation
end

--[[--
Access constant maximum quantity of holy power points.
@function getMaxHolyPower
@treturn number positive integer
]]
local function getMaxHolyPower()
	return 3
end

--[[--
Query the amount of holy power given unit currently possesses.
@function getUnitHolyPower
@tparam string unitDesignation unit to query
@treturn number positive integer
]]
local function getUnitHolyPower(unitDesignation)
	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)

	local hppq = UnitPower(unitDesignation, SPELL_POWER_HOLY_POWER)
	assert ('number' == type(hppq))
	assert (hppq >= 0)
	assert (hppq <= 1024)
	hppq = math.abs(math.ceil(hppq))

	local maxQuantity = getMaxHolyPower()
	assert (maxQuantity ~= nil)
	assert (hppq <= maxQuantity)

	return hppq
end

--[[--
Access the time instance when given holy power indicator last detected power change.
@function getDecayInstance
@tparam frame holyPowerIndicatorFrame this frame
@treturn number time instance
]]
local function getDecayInstance(holyPowerIndicatorFrame)
	local decayInstance = holyPowerIndicatorFrame.decayInstance
	if nil == decayInstance then
		decayInstance = 0
	end
	if 'number' ~= type(decayInstance) then
		decayInstance = 0
	end
	decayInstance = math.abs(decayInstance)

	assert (decayInstance ~= nil)
	assert ('number' == type(decayInstance))
	assert (decayInstance >= 0)

	return decayInstance
end

--[[--
Calcualte color that holy power indicator should be assigned with given unit state.
@function produceHolyPowerIndicatorColor
@tparam string unitDesignation unit associated with holy power indicator
@return red green blue coef
]]
local function produceHolyPowerIndicatorColor(unitDesignation)
	assert (unitDesignation ~= nil)

	local combatFlag = 1 == UnitAffectingCombat(unitDesignation) or false
	if combatFlag then
		return getHolyPowerIndicatorColor()
	else
		return getHolyPowerIndicatorDecayColor()
	end
end

--[[--
Calcualte transparency that holy power indicator should be assigned with given unit state.
@function produceHolyPowerIndicatorColor
@tparam string unitDesignation unit associated with holy power indicator
@return alpha coef
]]
local function produceHolyPowerIndicatorTransparency(unitDesignation, decayInstance)
	assert (unitDesignation ~= nil)
	assert (decayInstance ~= nil)

	local combatFlag = 1 == UnitAffectingCombat(unitDesignation) or false
	local a = 1
	if not combatFlag then
		local holyPowerPointLifespan = 10
		local now = GetTime()
		decayInstance = math.min(decayInstance, now)
		local decayDuration = math.min(math.max(0, now - decayInstance), holyPowerPointLifespan)
		a = 1 - decayDuration / holyPowerPointLifespan
	end
	return math.min(math.max(0, a), 1)
end

--[[--
Update holy power indicator appearance.
@function applyHolyPowerIndicatorCombat
]]
local function applyHolyPowerIndicatorCombat(self)
	assert (self ~= nil)

	local unitDesignation = getHolyPowerIndicatorUnitDesignation(self)
	assert (unitDesignation ~= nil)

	local hppq = getUnitHolyPower(unitDesignation)
	if hppq < 1 then
		return
	end
	local t = getIndicatorTable(self)
	assert (t ~= nil)
	--[[ Access last holy power indicator ]]--
	local q = t[hppq]
	--[[ Then render it partially transparent to indicate
	--   that it decays out of combat ]]--
	local i = 0
	local r, g, b = produceHolyPowerIndicatorColor(unitDesignation)
	while (i < hppq - 1) do
		i = i + 1
		local p = t[i]
		p:SetTexture(r, g, b, 1)
	end
	if q then
		local decayInstance = getDecayInstance(self)
		assert (decayInstance ~= nil)
		local a = produceHolyPowerIndicatorTransparency(unitDesignation, decayInstance)
		a = math.min(math.max(0.34, a + 0.34), 1)
		q:SetTexture(r, g, b, a)
	end
end

--[[--
Update holy power indicator last update time instance.
@function acceptHolyPowerIndicatorCombatLogEvent
]]
local function acceptHolyPowerIndicatorCombatLogEvent(holyPowerIndicator, eventCategory, instance,
                                                      combatLogEventCategory, ...)
	assert (eventCategory ~= nil)
	assert (instance ~= nil)

	local unitDesignation = getHolyPowerIndicatorUnitDesignation(holyPowerIndicator) or 'player'
	local unitName = select(7, ...)
	local playerName = UnitName(unitDesignation)
	if 'SPELL_ENERGIZE' == combatLogEventCategory and playerName == unitName then
		holyPowerIndicator.decayInstance = GetTime()
	end
end

--[[--
Process UNIT_POWER event for holy power indicator.
@function acceptHolyPowerIndicatorUnitPower
@tparam frame self this holy power indicator
]]
local function acceptHolyPowerIndicatorUnitPower(self)
	assert (self ~= nil)

	local unitDesignation = getHolyPowerIndicatorUnitDesignation(self)
	assert (unitDesignation ~= nil)

	--[[ Assume the table is sorted appropriately ]]--
	local t = getIndicatorTable(self)
	assert (t ~= nil)

	local maxQuantity = getMaxHolyPower()
	assert (maxQuantity ~= nil)

	--[[ Access the quantity of holy power point property of a given unit ]]--
	local hppq = getUnitHolyPower(unitDesignation)
	assert (hppq ~= nil)

	--[[ Display the indicators according the quantity of unit holy power points ]]--
	local combatFlag = 1 == UnitAffectingCombat(unitDesignation) or false

	local prevCombatFlag = self.combatFlag or false
	local unitLeftCombat = not combatFlag and prevCombatFlag
	if unitLeftCombat then
		self.decayInstance = GetTime()
	end
	local prevUnitPower = self.unitPower or 0
	local powerDecayed = not combatFlag and prevUnitPower ~= hppq and hppq > 0
	if powerDecayed then
		self.decayInstance = GetTime()
	end
	self.unitPower = hppq
	self.combatFlag = combatFlag

	local i = 0
	while (i < hppq) do
		i = i + 1
		local p = t[i]
		assert (p ~= nil)
		p:Show()
	end

	while (i < maxQuantity) do
		i = i + 1
		local p = t[i]
		assert (p ~= nil)
		p:Hide()
	end
end

local function holyPowerIndicatorEventProcessor(holyPowerIndicator, eventCategory, ...)
	if 'COMBAT_LOG_EVENT_UNFILTERED' == eventCategory then
		acceptHolyPowerIndicatorCombatLogEvent(holyPowerIndicator, eventCategory, ...)
	elseif 'UNIT_POWER_FREQUENT' == eventCategory then
		acceptHolyPowerIndicatorUnitPower(holyPowerIndicator, eventCategory, ...)
	end
end

--[[--
Produce frame that tracks and displays given unit holy power.
The new frame possesses custom attribute "unit".
@function createHolyPowerIndicator
@tparam string frameName conventionally unique frame desgination
@tparam frame parentFrame parent frame
@tparam string unitDesignation associated unit designation
@treturn frame newly allocated frame
]]
local function createHolyPowerIndicator(frameName, parentFrame, unitDesignation)
	assert (frameName ~= nil)
	assert ('string' == type(frameName))
	assert (string.len(frameName) >= 2)
	assert (string.len(frameName) <= 256)

	assert (parentFrame ~= nil)

	assert (unitDesignation ~= nil)
	assert ('string' == type(unitDesignation))
	assert (string.len(unitDesignation) >= 2)
	assert (string.len(unitDesignation) <= 256)

	local f = CreateFrame('FRAME', frameName, parentFrame)
	local size = 24
	local padding = 4
	local maxQuantity = getMaxHolyPower()
	f:SetSize(maxQuantity * (size + padding) + 4, size + padding + 4)

	local background = f:CreateTexture(frameName .. 'Background', 'BACKGROUND')
	background:SetAllPoints()
	background:SetTexture(0, 0, 0, 0.64)
	f.background = background

	local t = {}
	local q = 0
	local x = 0
	local y = 0
	while (q < maxQuantity) do
		q = q + 1
		local p = f:CreateTexture(frameName .. tostring(q), 'OVERLAY')
		p:SetTexture(getHolyPowerIndicatorColor())
		p:SetSize(size, size)
		p:SetPoint('BOTTOMLEFT', padding + x * (size + padding), y + padding)
		p:Hide()
		x = x + 1
		t[q] = p
	end

	f.unit = unitDesignation
	f.children = t

	f:RegisterEvent('COMBAT_LOG_EVENT_UNFILTERED')
	f:RegisterEvent('UNIT_POWER_FREQUENT')
	f:SetScript('OnEvent', holyPowerIndicatorEventProcessor)
	f:SetScript('OnUpdate', applyHolyPowerIndicatorCombat)
	return f
end

local function initPowerBar(rootFrame)
	assert (rootFrame ~= nil)

	local _, c = UnitClass('player')
	if 'PALADIN' ~= c then
		return
	end

	local hpf = createHolyPowerIndicator('DaybreakHolyPowerPlayerFrame', rootFrame, 'player')
	hpf:SetPoint('CENTER', 0, 0)
	hpf:SetPoint('BOTTOM', 0, 0)

	PaladinPowerBar:Hide()
	PaladinPowerBar:SetScript('OnEvent', nil)
	PaladinPowerBar:SetScript('OnLoad', nil)
	PaladinPowerBarBG:Hide()

	return hpf
end

--[[--
Lose control indicator.
@section cyclone
]]

local function createCycloneButton(column, row, localizedSpellName, buttonDesignation, parentFrame)
	return createButton(column, row, localizedSpellName, buttonDesignation, parentFrame, 'HARMFUL')
end

--[[--
Initialize character lose control indicators.
@function initCyclone
@tparam frame rootFrame parent frame
@treturn frame newly allocated frame
]]
local function initCyclone(rootFrame)
	--[[ Row: lose control category; column: debuff type (magic, poison, phys) ]]--
	local p = CreateFrame('FRAME', 'DaybreakCycloneHeader', rootFrame)
	p:SetSize(32 * 4, 32 * 4)
	p:SetPoint('CENTER', 0, 0)

	--[[ Ass ]]--
	createCycloneButton(2, 4, 'Cyclone', 'DaybreakCycloneCyclone', p)

	--[[ Stun ]]--
	createCycloneButton(2, 1, 'Charge', 'DaybreakCycloneCharge', p)
	createCycloneButton(2, 1, 'Cheap Shot', 'DaybreakCycloneCheapShot', p)
	createCycloneButton(2, 1, 'Concussion Blow', 'DaybreakCycloneConcussionBlow', p)
	createCycloneButton(2, 1, 'Fire Blast', 'DaybreakCycloneFireBlast', p)
	createCycloneButton(2, 1, 'Gnaw', 'DaybreakCycloneGnaw', p)
	createCycloneButton(2, 1, 'Intercept', 'DaybreakCycloneIntercept', p)
	createCycloneButton(2, 1, 'Kidney Shot', 'DaybreakCycloneKidenyShot', p)
	createCycloneButton(2, 1, 'Shockwave', 'DaybreakCycloneShockwave', p)
	createCycloneButton(2, 1, 'Throwdown', 'DaybreakCycloneThrowdown', p)
	createCycloneButton(2, 4, 'Deep Freeze', 'DaybreakCycloneDeepFreeze', p)
	createCycloneButton(2, 4, 'Hammer of Justice', 'DaybreakCycloneHammerOfJustice', p)

	--[[ Disorient ]]--
	createCycloneButton(1, 1, 'Blind', 'DaybreakCycloneBlind', p)
	createCycloneButton(1, 1, 'Gouge', 'DaybreakCycloneGouge', p)
	createCycloneButton(1, 1, 'Sap', 'DaybreakCycloneSap', p)
	createCycloneButton(1, 2, 'Hex', 'DaybreakCycloneHex', p)
	createCycloneButton(1, 4, 'Death Coil', 'DaybreakCycloneFear', p)
	createCycloneButton(1, 4, 'Dragon Breath', 'DaybreakCycloneDragonBreath', p)
	createCycloneButton(1, 4, 'Fear', 'DaybreakCycloneFear', p)
	createCycloneButton(1, 4, 'Feezing Trap', 'DaybreakCycloneFreezingTrap', p)
	createCycloneButton(1, 4, 'Holy Word: Chastise', 'DaybreakCycloneHolyWordChastise', p)
	createCycloneButton(1, 4, 'Howl of Terror', 'DaybreakCycloneFear', p)
	createCycloneButton(1, 4, 'Intimidating Shout', 'DaybreakCycloneIntimidatingShout', p)
	createCycloneButton(1, 4, 'Polymorph', 'DaybreakCycloneFear', p)
	createCycloneButton(1, 4, 'Ring of Frost', 'DaybreakCycloneRingOfFrost', p)

	--[[ Silence ]]--
	createCycloneButton(1, 1, 'Gag Order', 'DaybreakCycloneGagOrder', p)
	createCycloneButton(1, 4, 'Counterspell', 'DaybreakCycloneCounterspell', p)
	createCycloneButton(1, 4, 'Silence', 'DaybreakCycloneSilence', p)
	createCycloneButton(1, 4, 'Spell Lock', 'DaybreakCycloneSpellLock', p)
	createCycloneButton(1, 4, 'Strangulate', 'DaybreakCycloneFear', p)

	--[[ Root ]]--
	createCycloneButton(0, 4, 'Frost Nova', 'DaybreakCycloneFrostNova', p)
	createCycloneButton(0, 4, 'Entangling Roots', 'DaybreakCycloneEntanglingRoots', p)

	--[[ Slow ]]--
	createCycloneButton(0, 1, 'Chains of Ice', 'DaybreakCycloneChainsOfIce', p)
	createCycloneButton(0, 1, 'Hamstring', 'DaybreakCycloneHamstring', p)
	createCycloneButton(0, 3, 'Crippling Poison', 'DaybreakCycloneCripplingPoison', p)
	createCycloneButton(0, 4, 'Cone of Cold', 'DaybreakCycloneConeOfCold', p)
	createCycloneButton(0, 4, 'Earthbind Totem', 'DaybreakCycloneEarthbindTotem', p)
	createCycloneButton(0, 4, 'Slow', 'DaybreakCycloneSlow', p)

	--[[ Healing reduction ]]--
	createCycloneButton(3, 1, 'Aimed Shot', 'DaybreakCycloneAimedShot', p)
	createCycloneButton(3, 1, 'Mortal Strike', 'DaybreakCycloneMortalStrike', p)
	createCycloneButton(3, 1, 'Necrotic Strike', 'DaybreakCycloneNecroticStrike', p)
	createCycloneButton(3, 3, 'Wound Poison', 'DaybreakCycloneWoundPoison', p)
	createCycloneButton(3, 2, 'Curse of Tongues', 'DaybreakCycloneCurseOfTongues', p)
end

--[[--
Beacon of light.
Add dedicated Beacon of Light indicator.
@section beacon
]]

local function beaconEventProcessor(self, ...)
	local combatLogEventCategory = select(3, ...)
	local unitName1 = select(6, ...)
	local unitName2 = select(10, ...)
	local spellName = select(14, ...)
	--[[print(combatLogEventCategory, unitName1, unitName2, spellName)]]--
	local playerName = UnitName('player')
	if playerName ~= unitName1 then
		return
	end
	if 'Beacon of Light' ~= spellName then
		return
	end
	if 'SPELL_AURA_APPLIED' == combatLogEventCategory or
	   'SPELL_AURA_REFRESH' == combatLogEventCategory then
		self.unitName = unitName2
		self:Show()
	end
	if 'SPELL_AURA_REMOVED' == combatLogEventCategory then
		self.unitName = nil
		self:Hide()
	end
end

local function beaconUpdateProcessor(self)
	if nil == self then
		return
	end
	local t = {
		'party1', 'party2', 'party3', 'party4',
		'raid1', 'raid2', 'raid3', 'raid4', 'raid5',
		'raid5', 'raid6', 'raid7', 'raid8', 'raid9',
		'raid10', 'raid11', 'raid12', 'raid13', 'raid14',
		'raid15', 'raid16', 'raid17', 'raid18', 'raid19',
		'raid20', 'raid21', 'raid22', 'raid23', 'raid24',
		'raid25', 'raid26', 'raid27', 'raid28', 'raid29',
		'raid30', 'raid31', 'raid32', 'raid33', 'raid34',
		'raid35', 'raid36', 'raid37', 'raid38', 'raid39',
		'player'
	}
	local m = self.unitName
	if nil == m then
		self:Hide()
		return
	end
	local d
	local i = 0
	while (i < #t) do
		i = i + 1
		local r = t[i]
		local n = UnitName(r)
		if n == m then
			d = r
			break
		end
	end
	if nil == d then
		self.unitName = nil
		self:Hide()
		return
	end
	if UnitIsDead(d) then
		self.unitName = nil
		self:Hide()
	end

	local artwork = self:GetNormalTexture()
	if 1 == IsSpellInRange('Beacon of Light', d) then
		artwork:SetVertexColor(1, 1, 1, 1)
	else
		artwork:SetVertexColor(1, 1, 1, 0.4)
	end
end

--[[--
Initialize player Beacon of Light buff indicator.
@function initBeacon
@tparam frame rootFrame parent frame
@treturn frame new frame that tracks the specific player buff
--]]
local function initBeacon(rootFrame)
	local beacon = createButton(11, 4, 'Beacon of Light', 'DaybreakOverlayPaladinBeaconOfLight', rootFrame)
	beacon:SetNormalTexture("Interface\\Icons\\Ability_Paladin_BeaconOfLight")

	beacon:UnregisterAllEvents()
	beacon:SetScript('OnEvent', beaconEventProcessor)
	beacon:SetScript('OnUpdate', beaconUpdateProcessor)
	beacon:RegisterEvent('COMBAT_LOG_EVENT_UNFILTERED')

	return beacon
end

--[[--
Blessed life.
Track availability of Blessed Life effect on the player character.
@section blessedlife
]]

--[[--
Query if the player character invested into Blessed Life talent.
@function isBlessedLifePresent
@treturn bool
]]
local function isBlessedLifePresent()
	local specNumber = 1
	local talentNumber = 19
	local _, _, _, _, a = GetTalentInfo(specNumber, talentNumber)
	if nil == a then
		return false
	end
	if 'number' ~= type(a) then
		return false
	end
	return a >= 1
end

--[[--
Process combat log events to track Blessed Life effect.
See COMBAT_LOG_EVENT event category.
@function acceptBlessedLifeCombatLogEvent
@tparam frame blessedLife self
]]
local function acceptBlessedLifeCombatLogEvent(blessedLife, eventCategory, instance,
                                               combatLogEventCategory, ...)
	assert (blessedLife ~= nil)
	assert (eventCategory ~= nil)
	assert (instance ~= nil)

	if not blessedLife.isEnabled then
		return
	end

	local now = GetTime()
	local unitDesignation = 'player'

	--[[ Process if blessed life effect occurred
	--   if it did, remember the time instance ]]--
	local unitName = select(7, ...)
	local playerName = UnitName(unitDesignation)
	if 'SPELL_ENERGIZE' == combatLogEventCategory and playerName == unitName then
		local spellName = select(11, ...)
		if 'Blessed Life' == spellName then
			blessedLife.lastEffectInstance = now
		end
	end

	--[[ Calculate amount of seconds passed since last proc ]]--
	local blessedLifeCooldown = 8
	local lastEffectInstance = blessedLife.lastEffectInstance or 0
	local blessedLifeReady = math.abs(now - lastEffectInstance) > blessedLifeCooldown

	--[[ If player is in combat and more than eight seconds passed since last proc
	--   then show that blessed life is ready to proc ]]--
	local combatFlag = 1 == UnitAffectingCombat(unitDesignation) or false
	if combatFlag and blessedLifeReady then
		blessedLife:Show()
	else
		blessedLife:Hide()
	end
end

--[[--
Detect if Blessed Life ability is still available after spell set change.
@function acceptBlessedLifeSpellsChanged
]]
local function acceptBlessedLifeSpellsChanged(blessedLife)
	assert (blessedLife ~= nil)
	blessedLife.isEnabled = isBlessedLifePresent()
end

--[[--
Route events that concern Blessed Life indicator.
@function blessedLifeEventProcessor
]]
local function blessedLifeEventProcessor(blessedLife, eventCategory, ...)
	if 'COMBAT_LOG_EVENT_UNFILTERED' == eventCategory then
		acceptBlessedLifeCombatLogEvent(blessedLife, eventCategory, ...)
	elseif 'PLAYER_TALENT_UPDATE' == eventCategory then
		acceptBlessedLifeSpellsChanged(blessedLife, eventCategory, ...)
	elseif 'SPELLS_CHANGED' == eventCategory then
		acceptBlessedLifeSpellsChanged(blessedLife, eventCategory, ...)
	end
end

--[[--
Create an indicator for Blessed Life effect for the player character.
@function initBlessedLife
@tparam frame rootFrame
@treturn frame
]]
local function initBlessedLife(rootFrame)
	assert (rootFrame ~= nil)

	local blessedLife = createButton(2, 0, 'Blessed Life', 'DaybreakOverlayPaladinBlessedLife', rootFrame)
	blessedLife:SetNormalTexture("Interface\\Icons\\Spell_holy_blessedlife")

	blessedLife:UnregisterAllEvents()
	blessedLife.isEnabled = isBlessedLifePresent()
	blessedLife:SetScript('OnEvent', blessedLifeEventProcessor)
	blessedLife:RegisterEvent('COMBAT_LOG_EVENT_UNFILTERED')
	blessedLife:RegisterEvent('PLAYER_TALENT_UPDATE')
	blessedLife:RegisterEvent('SPELLS_CHANGED')

	blessedLife:Hide()

	return blessedLife
end

--[[--
Priest overlay.
Priest spell activation overlay.
@section serendipity
]]

--[[--
Initialize priest spell activation overlay if necessary.
Must only be called once per script lifetime.
Assumes that player class is constant.
@function initSerendipity
@tparam frame rootFrame addon root frame to parent indicators from
@return void
]]
local function initSerendipity(rootFrame)
	assert (rootFrame ~= nil)

	local _, classDesignation = UnitClass('player')
	if 'PRIEST' ~= classDesignation then
		return
	end

	--[[ Priest ]]--
	createButton(0, 0, 'Chakra: Chastise', 'DaybreakOverlayPriestChakraChastise', rootFrame)
	createButton(0, 0, 'Chakra: Sanctuary', 'DaybreakOverlayPriestChakraSanctuary', rootFrame)
	createButton(0, 0, 'Chakra: Serenity', 'DaybreakOverlayPriestChakraSerenity', rootFrame)
	createButton(0, 1, 'Chakra', 'DaybreakOverlayPriestChakra', rootFrame)
	--[[ Holy ]]--
	createButton(1, 0, 'Holy Word: Serenity', 'DaybreaksOverlayPriestHolyWordSerenity', rootFrame)
	createButton(1, 1, 'Surge of Light', 'DaybreakOverlayPriestSurgeOfLight', rootFrame)
	createButton(1, 2, 'Serendipity', 'DaybreakOverlayPriestSerendipity', rootFrame)
	createButton(1, 3, 'Guardian Spirit', 'DaybreakOverlayPriestGuardianSpirit', rootFrame)

	--[[ Priest general ]]--
	createButton(9, 0, 'Inspiration', 'DaybreakOverlayPriestInspiration', rootFrame)
	createButton(9, 1, 'Renew', 'DaybreakOverlayPriestRenew', rootFrame)
	createButton(9, 2, 'Power Word: Shield', 'DaybreakOverlayPriestPowerWordShield', rootFrame)
	createButton(10, 2, 'Body and Soul', 'DaybreakOverlayPriestBodyAndSoul', rootFrame)

	--[[ Hide native spell proc indicators that flash in the middle of the screen ]]--
	SetCVar("displaySpellActivationOverlays", false)
end

--[[--
Paladin overlay.
Paladin spell activation overlay.
@section daybreak
]]

--[[--
Initialize paladin spell activation overlay if necessary.
Must only be called once per script lifetime.
Assumes that player class is constant.
@function initDaybreak
@tparam frame rootFrame addon root frame to parent indicators from
@return void
]]
local function initDaybreak(rootFrame)
	assert (rootFrame ~= nil)

	local _, classDesignation = UnitClass('player')
	if 'PALADIN' ~= classDesignation then
		return
	end

	--[[ Paladin ]]--
	--[[ General ]]--
	createButton(0, 0, 'Crusader', 'DaybreakOverlayPaladinCrusader', rootFrame)
	createButton(0, 1, 'Divine Plea', 'DaybreakOverlayPaladinDivinePlea', rootFrame)
	createButton(0, 2, 'Divine Protection', 'DaybreakOverlayPaladinDivineProtection', rootFrame)
	createButton(0, 2, 'Divine Shield', 'DaybreakOverlayPaladinDivineShield', rootFrame)
	createButton(0, 3, 'Avenging Wrath', 'DaybreakOverlayPaladinAvengingWrath', rootFrame)
	createButton(0, 4, 'Guardian of Ancient Kings', 'DaybreakOverlayPaladinGuardianOfTheAncientKings', rootFrame)

	createButton(11, 0, 'Concentration Aura', 'DaybreakOverlayPaladinConcentrationAura', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 0, 'Crusader Aura', 'DaybreakOverlayPaladinCrusaderAura', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 0, 'Devotion Aura', 'DaybreakOverlayPaladinDevotionAura', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 0, 'Resistance Aura', 'DaybreakOverlayPaladinResistanceAura', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 0, 'Retribution Aura', 'DaybreakOverlayPaladinRetributionAura', rootFrame, 'PLAYER HELPFUL')

	createButton(11, 1, 'Seal of Insight', 'DaybreakOverlayPaladinSealOfInsight', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 1, 'Seal of Justice', 'DaybreakOverlayPaladinSealOfJustice', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 1, 'Seal of Righteousness', 'DaybreakOverlayPaladinSealOfRighteousness', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 1, 'Seal of Truth', 'DaybreakOverlayPaladinSealOfTruth', rootFrame, 'PLAYER HELPFUL')

	createButton(11, 2, 'Blessing of Might', 'DaybreakOverlayPaladinBlessingOfMight', rootFrame, 'PLAYER HELPFUL')
	createButton(11, 2, 'Blessing of Kings', 'DaybreakOverlayPaladinBlessingOfKings', rootFrame, 'PLAYER HELPFUL')

	--[[ Effects that may be applied by other players place on the right side ]]--
	createButton(9, 0, 'Hand of Freedom', 'DaybreakOverlayPaladinHandOfFreedom', rootFrame)
	createButton(9, 1, 'Hand of Sacrifice', 'DaybreakOverlayPaladinHandOfSacrifice', rootFrame)
	createButton(9, 2, 'Hand of Protection', 'DaybreakOverlayPaladinHandOfProtection', rootFrame)
	createButton(9, 3, 'Divine Sacrifice', 'DaybreakOverlayPaladinDivineSacrifice', rootFrame)
	createButton(9, 4, 'Aura Mastery', 'DaybreakOverlayPaladinAuraMastery', rootFrame)
	createButton(10, 0, 'Illuminated Healing', 'DaybreakOverlayPaladinIlluminatedHealing', rootFrame)
	createButton(10, 1, 'Conviction', 'DaybreakOverlayPaladinConviction', rootFrame)
	createButton(10, 2, 'Power Torrent', 'DaybreakOverlayPaladinPowerTorrent', rootFrame)
	createButton(10, 3, 'Surge of Dominance', 'DaybreakOverlayPaladinSurgeOfDominance', rootFrame)

	--[[ Holy ]]--
	createButton(1, 0, 'Judgements of the Pure', 'DaybreakOverlayPaladinJudgementsOfThePure', rootFrame)
	createButton(1, 2, 'Daybreak', 'DaybreakOverlayPaladinDaybreak', rootFrame)
	createButton(1, 3, 'Infusion of Light', 'DaybreakOverlayPaladinInfusionOfLight', rootFrame)
	createButton(1, 4, 'Divine Favor', 'DaybreakOverlayPaladinDivineFavor', rootFrame)

	--[[ Protection ]]--
	createButton(1, 0, 'Guarded by the Light', 'DaybreakOverlayPaladinGuardedByTheLight', rootFrame)
	createButton(1, 1, 'Holy Shield', 'DaybreakOverlayPaladinHolyShield', rootFrame)
	createButton(1, 2, 'Ardent Defender', 'DaybreakOverlayPaladinArdentDefender', rootFrame)
	createButton(1, 3, 'Grand Crusader', 'DaybreakOverlayPaladinGrandCrusader', rootFrame)
	createButton(1, 4, 'Sacred Duty', 'DaybreakOverlayPaladinSacredDuty', rootFrame)

	--[[ Retribution ]]--
	createButton(10, 4, 'Inquisition', 'DaybreakOverlayPaladinInquisition', rootFrame)

	--[[ Hide native spell proc indicators that flash in the middle of the screen ]]--
	SetCVar("displaySpellActivationOverlays", false)
end

--[[--
When variables loaded then create and configure all required frames.
Must only be executed once per script lifetime.
@function init
@tparam frame rootFrame
@treturn frame updated given root frame
]]
local function init(rootFrame)
	assert (rootFrame ~= nil)

	rootFrame:SetSize(384, 256)
	rootFrame:SetPoint('CENTER', UIParent,
	                   'CENTER', 0, 0)

	initCyclone(rootFrame)
	initBeacon(rootFrame)
	initBlessedLife(rootFrame)
	initDaybreak(rootFrame)
	initPowerBar(rootFrame)
	initRole(rootFrame)
	initSerendipity(rootFrame)

	print('[Daybreak]: Addon loaded.')

	return rootFrame
end

--[[--
Daybreak script entry point.
Must only be executed once per script life time.
@function main
]]
local function main()
	local rootFrame = CreateFrame('FRAME', 'DaybreakFrame', UIParent)
	rootFrame:SetScript('OnEvent', init)
	rootFrame:RegisterEvent('VARIABLES_LOADED')
end
main()