local GetSpellName = GetSpellName
local IsSpellInRange = IsSpellInRange

local MAX_SPELLS = MAX_SPELLS

local Chorus = Chorus

--[[ See ChorusRangeFrameTemplate.lua:function spellRangeMapUpdate. ]]--
--[[ See ChorusRangeFrameTemplate.lua:function rangeFrameUpdate. ]]--
local spellRangeMap = {}

local function spellRangeMapUpdate()
	local maxSpells = MAX_SPELLS or 1024
	maxSpells = math.min(math.max(1, math.abs(math.floor(maxSpells)), 8192))

	local buffer = {}

	local i = 0
	while (i < maxSpells) do
		i = i + 1

		--[[ Get player spell book button number "i", and request it's
		     corresponding spell name. This is NOT a unique spell
		     identifier. Every spell rank is a separate button. ]]--
		local spellName = GetSpellName(i, 'player')
		if not spellName then
			break
		end

		--[[ When GetSpellInfo is called with localized spell name
		     string, it only returns data on the spells stored in the
		     current player character's spell book. ]]--
		local _, _, _, _, _, _, _, _, maxRangeYards = GetSpellInfo(spellName)
		if spellName and maxRangeYards then
			assert(spellName ~= nil)
			assert('string' == type(spellName))
			spellName = strtrim(spellName)
			assert(string.len(spellName) >= 1)
			assert(string.len(spellName) <= 8192)

			assert(maxRangeYards ~= nil)
			assert('number' == type(maxRangeYards))
			maxRangeYards = math.abs(math.floor(maxRangeYards))

			if maxRangeYards >= 1 then
				local oldRangeYards = spellRangeMap[spellName]

				--[[
				Previous rank of the spell already mapped.
				Only the most potentially efficient spell rank
				will be mapped. ]]--

				if oldRangeYards then
					maxRangeYards = math.max(maxRangeYards, oldRangeYards)
				end

				--[[
				Priest spell "Mind Vision" has range of 50_000
				yards. This isn't a useful specificity, so
				filter it out. Only allow spell ranges that can
				be reasonably displayed and understood by the
				user during game combat play. Do not round down
				the value itself. Only store correct
				values.]]--
				if maxRangeYards < 99 then
					buffer[spellName] = maxRangeYards
				end
			end
		end
	end

	--[[ At this point assume no errors occurred. Re-write the actual spell
	     range map. ]]--
	spellRangeMap = buffer
end

local function rangeFrameUpdate(self)
	assert(self ~= nil)

	local unitDesignation = SecureButton_GetUnit(self) or 'none'

	assert(unitDesignation ~= nil)
	assert('string' == type(unitDesignation))
	unitDesignation = string.lower(strtrim(unitDesignation))
	assert(string.len(unitDesignation) >= 1)
	assert(string.len(unitDesignation) <= 256)

	local label = self.label or _G[self:GetName() .. 'Text']
	assert(label ~= nil)

	--[[ Frame must be always shown to keep update processor running. ]]--
	if not UnitExists(unitDesignation) or UnitIsUnit('player', unitDesignation) then
		label:SetText(nil)
		return
	end

	local rangeFlag = nil
	local distanceYards = nil
	local maxRangeYards = 0
	for spellName, rangeYards in pairs(spellRangeMap) do
		local flag = IsSpellInRange(spellName, unitDesignation)
		--[[ 1 == flag: in range; ]]--
		--[[ 0 == flag: out of range; ]]--
		--[[ nil == flag: not applicable or cannot be cast on given target. ]]--
		if not rangeFlag and flag then
			rangeFlag = flag
		end
		if nil ~= flag then
			maxRangeYards = math.max(rangeYards, maxRangeYards)
		end
		if 1 == flag then
			rangeFlag = 1
			if not distanceYards then
				distanceYards = rangeYards
			end
			distanceYards = math.min(distanceYards, rangeYards)
		end
	end

	local t
	if 1 == rangeFlag then
		t = string.format('<%d yd', distanceYards)
		label:SetTextColor(1, 1, 1)
	elseif 0 == rangeFlag then
		t = string.format('>%d yd', maxRangeYards)
		label:SetTextColor(1, 0, 0)
	else
		t = nil
	end
	label:SetText(t)
end

local function rangeFrameUpdateProcessor(self)
	assert(self ~= nil)

	--[[ Reduce update frequency to roughly 6 frames per second. ]]--
	if self.lastUpdateInstance and 'number' == type(self.lastUpdateInstance) then
		local now = GetTime()
		if now - self.lastUpdateInstance > 0.1667 then
			self.lastUpdateInstance = now
		else
			return
		end
	end

	rangeFrameUpdate(self)
end

local function rangeFrameMain(self)
	assert(self ~= nil)

	self.label = _G[self:GetName() .. 'Text']
	self:SetScript('OnUpdate', rangeFrameUpdateProcessor)
end

local function rangeSpellMapFrameMain(self)
	assert(self ~= nil)

	self:RegisterEvent('ACTIVE_TALENT_GROUP_CHANGED')
	self:RegisterEvent('LEARNED_SPELL_IN_TAB')
	self:RegisterEvent('PLAYER_LOGIN')
	self:RegisterEvent('PLAYER_TALENT_UPDATE')
	self:RegisterEvent('SPELLS_CHANGED')
	self:SetScript('OnEvent', spellRangeMapUpdate)

	RegisterUnitWatch(self)
end

--[[ Hide reference to the internal function, for some reason. ]]--
Chorus.rangeFrameMain = function(...)
	return rangeFrameMain(...)
end

Chorus.rangeSpellMapFrameMain = function(...)
	return rangeSpellMapFrameMain(...)
end