--[[--
Add paladin player aura indicator.
@script daybreak
]]

--[[--
Shared constants.
@section constant
]]

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

--[[--
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 ]]--
	local roleDesignation = 'NONE'
	local _, classDesignation = UnitClass(unitDesignation)
	local i = GetPrimaryTalentTree()
	if '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
		if 1 == i then
			roleDesignation = 'DAMAGER'
		elseif 2 == i then
			roleDesignation = 'DAMAGER'
		elseif 3 == i then
			roleDesignation = 'DAMAGER'
		end
	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

--[[--
Unit holy power indicator.
@section holypower
]]

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 initHolyPower(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

--[[--
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

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

local function initBeacon(rootFrame)
	local beacon = CreateFrame('FRAME', 'DaybreakBeaconOfLightFrame', rootFrame)
	beacon:SetSize(28, 28)
	beacon:SetPoint('BOTTOMLEFT', 10 * 32, 3 * 32)

	local artwork = beacon:CreateTexture(beacon:GetName() .. 'Artwork', 'ARTWORK')
	artwork:SetAllPoints()
	artwork:SetTexture("Interface\\Icons\\Ability_Paladin_BeaconOfLight")
	beacon.artwork = artwork

	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 = CreateFrame('FRAME', 'DaybreakBlessedLifeFrame', rootFrame)
	local size = getDefaultButtonSize()
	local padding = math.max(32 - size, 0)
	local s = size + padding
	local column = 2
	local row = 0
	blessedLife:SetSize(size, size)
	blessedLife:SetPoint('BOTTOMLEFT', s * column, s * row)

	local artwork = blessedLife:CreateTexture(blessedLife:GetName() .. 'Artwork', 'ARTWORK')
	artwork:SetAllPoints()
	artwork:SetTexture("Interface\\Icons\\Spell_holy_blessedlife")
	blessedLife.artwork = artwork

	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

--[[--
Paladin character buff tracker.
@section daybreak
]]

--[[--
Process timer tick to update remaining aura duration.
The update employs artificial delay to hopefully reduce the memory cost of updates.
@function applyUpdate
@tparam frame button button to update
@tparam number updateDurationSec amount of seconds elapsed since last update
@return nothing
]]
local function applyUpdate(button, updateDurationSec)
	assert (button ~= nil)

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

	local updateCooldownDurationSec = button.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
		button.updateCooldownDurationSec = updateCooldownDurationSec
		return
	else
		updateCooldownDurationSec = 0.084
		button.updateCooldownDurationSec = updateCooldownDurationSec
	end

	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 _, _, _, _, _, duration, expirationInstance = UnitBuff(unitDesignation, auraName)
	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
	if isDurationUnlimited then
		remainingDuration = nil
	end
	button:SetText(remainingDuration)
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 acceptUnitAura
@tparam button frame this button frame to update
@tparam string eventCategory given event category designation
@return nothing
]]
local function acceptUnitAura(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 name, _, icon = UnitBuff(unitDesignation, auraName)
	if name then
		--[[ FIXME Apply graphics only once instead of every aura update ]]--
		button:SetNormalTexture(icon)
		button:Show()
		button:SetScript('OnUpdate', applyUpdate)
	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)
	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:SetAllPoints()

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

	button.spell = localizedSpellName
	button.unit = 'player'

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

	button:Hide()

	return button
end

local function initDaybreak(rootFrame)
	--[[ Paladin ]]--
	--[[ General ]]--
	createButton(0, 0, 'Crusader', 'DaybreakButton01', rootFrame)
	createButton(0, 1, 'Divine Plea', 'DaybreakButton02', rootFrame)
	createButton(0, 2, 'Divine Protection', 'DaybreakButton03', rootFrame)
	createButton(0, 2, 'Divine Shield', 'DaybreakButton04', rootFrame)
	createButton(0, 3, 'Avenging Wrath', 'DaybreakButton05', rootFrame)
	createButton(0, 4, 'Guardian of Ancient Kings', 'DaybreakButton06', rootFrame)

	--[[ Effects that may be applied by other players place on the right side ]]--
	createButton(9, 0, 'Hand of Freedom', 'DaybreakButton07', rootFrame)
	createButton(9, 1, 'Hand of Sacrifice', 'DaybreakButton08', rootFrame)
	createButton(9, 2, 'Hand of Protection', 'DaybreakButton09', rootFrame)
	createButton(9, 3, 'Divine Sacrifice', 'DaybreakButton10', rootFrame)
	createButton(10, 0, 'Illuminated Healing', 'DaybreakButton11', rootFrame)

	--[[ Holy ]]--
	createButton(1, 0, 'Judgements of the Pure', 'DaybreakButton12', rootFrame)
	createButton(1, 1, 'Daybreak', 'DaybreakButton13', rootFrame)
	createButton(1, 2, 'Infusion of Light', 'DaybreakButton14', rootFrame)
	createButton(1, 3, 'Divine Favor', 'DaybreakButton15', rootFrame)
	createButton(1, 4, 'Aura Mastery', 'DaybreakButton16', rootFrame)

	--[[ Protection ]]--
	createButton(1, 0, 'Guarded by the Light', 'DaybreakButton17', rootFrame)
	createButton(1, 1, 'Holy Shield', 'DaybreakButton18', rootFrame)
	createButton(1, 2, 'Ardent Defender', 'DaybreakButton19', rootFrame)
	createButton(1, 3, 'Grand Crusader', 'DaybreakButton20', rootFrame)
	createButton(1, 4, 'Sacred Duty', 'DaybreakButton21', rootFrame)

	--[[ Retribution ]]--
	createButton(10, 1, 'Inquisition', 'DaybreakButton22', rootFrame)

	--[[ Priest ]]--
	local _, classDesignation = UnitClass('player')
	if 'PRIEST' == classDesignation then
		createButton(0, 0, 'Chakra: Chastise', 'DaybreakChakraChastiseButton', rootFrame)
		createButton(0, 0, 'Chakra: Sanctuary', 'DaybreakChakraSanctuaryButton', rootFrame)
		createButton(0, 0, 'Chakra: Serenity', 'DaybreakChakraSerenityButton', rootFrame)
		createButton(0, 1, 'Chakra', 'DaybreakChakraButton', rootFrame)
		--[[ Holy ]]--
		createButton(1, 0, 'Holy Word: Serenity', 'DaybreaksHolyWordSerenityButton', rootFrame)
		createButton(1, 1, 'Surge of Light', 'DaybreakSurgeOfLightButton', rootFrame)
		createButton(1, 2, 'Serendipity', 'DaybreakSerendipityButton', rootFrame)
		createButton(1, 3, 'Guardian Spirit', 'DaybreakGuardianSpiritButton', rootFrame)

		--[[ Priest general ]]--
		createButton(9, 0, 'Inspiration', 'DaybreakInspirationButton', rootFrame)
		createButton(9, 1, 'Renew', 'DaybreakRenewButton', rootFrame)
		createButton(9, 2, 'Power Word: Shield', 'DaybreakPowerWordShieldButton', rootFrame)
		createButton(10, 2, 'Body and Soul', 'DaybreakBodyAndSoulButton', rootFrame)
	end

	--[[ 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)

	initBlessedLife(rootFrame)
	initDaybreak(rootFrame)
	initHolyPower(rootFrame)
	initRole(rootFrame)
	initBeacon(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()