if( not PaladinBuffer ) then return end



local Assign = PaladinBuffer:NewModule("Assign", "AceEvent-3.0", "AceComm-3.0")

local blessings, priorities, currentSort, assignments, blacklist

local singleToGreater = {["might"] = "gmight", ["kings"] = "gkings", ["wisdom"] = "gwisdom", ["sanct"] = "gsanct"}

local pointsInfo = {}



-- Create our tables for doing smart assignments

function Assign:CreateTables()

	if( blessings ) then

		return

	end

	

	-- People we've already used

	blacklist = {}

	

	-- Blessings

	blessings = {}

	for spellToken, type in pairs(PaladinBuffer.blessingTypes) do

		if( type == "greater" ) then

			blessings[spellToken] = {}

		end

	end

	

	self.blessings = blessings

	

	-- Blessing priorities for people

	priorities = {

		["ROGUE"] = {"gkings", "gmight", "gsanct"},

		["WARRIOR"] = {"gkings", "gmight", "gsanct"},

		["DEATHKNIGHT"] = {"gkings", "gmight", "gsanct"},

		["PRIEST"] = {"gkings", "gwisdom", "gsanct"},

		["WARLOCK"] = {"gkings", "gwisdom", "gsanct"},

		["MAGE"] = {"gkings", "gwisdom", "gsanct"},

		["HUNTER"] = {"gkings", "gmight", "gwisdom", "gsanct"},

		["PALADIN"] = {"gkings", "gwisdom", "gmight", "gsanct"},

		["DRUID"] = {"gkings", "gwisdom", "gmight", "gsanct"},

		["SHAMAN"] = {"gkings", "gwisdom", "gmight", "gsanct"},

	}

	

	-- Set assignments for classes

	assignments = {}

	for classToken in pairs(priorities) do

		assignments[classToken] = {}

	end



	self.assignments = assignments

end



-- Sort the tables so the people with the highest rank of blessings come first

local function sortOrder(a, b)

	if( not a ) then

		return false

	elseif( not b ) then

		return true

	end

	

	return pointsInfo[a] < pointsInfo[b]

end



function Assign:SetHighestBlessers(classToken)

	-- Reset our list

	for _, list in pairs(blessings) do for i=#(list), 1, -1 do table.remove(list, i) end end

	

	-- Load the list of players by blessing into a table

	for name, data in pairs(PaladinBuffer.db.profile.blessings) do

		for spellToken, rank in pairs(data) do

			if( rank ~= "none" and PaladinBuffer.blessingTypes[spellToken] == "greater" ) then

				table.insert(blessings[spellToken], name)

			end

		end

	end

	

	-- Now go through that list

	for spellToken, list in pairs(blessings) do

		currentSort = spellToken

		

		-- What this does is find the person who is least likely to conflict with someone else, and ultimately give the highest blessing assignment		

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

		for name, data in pairs(PaladinBuffer.db.profile.blessings) do

			pointsInfo[name] = pointsInfo[name] or 0



			for token, rank in pairs(data) do

				if( token == spellToken ) then

					pointsInfo[name] = pointsInfo[name] - (rank * 1000)

				else

					-- Find the blessing priority

					local priority = 10

					for pID, pToken in pairs(priorities[classToken]) do

						if( pToken == token ) then

							priority = pID * 10

							break

						end

					end



					-- Add it up

					pointsInfo[name] = pointsInfo[name] + (rank * (100 - priority))

				end

			end

		end



		-- Sort it with our least likely conflicter

		table.sort(list, sortOrder)

	end

end



function Assign:CalculateBlessings()

	self:CreateTables()

	

	-- Reset assignments

	for _, list in pairs(assignments) do for k in pairs(list) do list[k] = nil end end

	

	-- Loop through and do all of our fancy assigning

	for classToken, classPriorities in pairs(priorities) do

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

		self:SetHighestBlessers(classToken)

		

		-- Loop through the priorities in order

		for _, spellToken in pairs(classPriorities) do

			-- Now find out who can do the highest rank of this, that isn't black listed

			for _, playerName in pairs(blessings[spellToken]) do

				if( not blacklist[playerName] ) then

					blacklist[playerName] = true



					assignments[classToken][playerName] = spellToken

					break

				end

			end

		end

	end

	

	-- Reset all previous assignments

	PaladinBuffer:ClearAllAssignments()

	

	-- Now assign the new ones

	for classToken, list in pairs(assignments) do

		for playerName, spellToken in pairs(list) do

			PaladinBuffer:AssignBlessing(playerName, spellToken, classToken)

		end

	end

end



function Assign:TotalSingleAssigns(spellToken, playerName)

	if( not PaladinBuffer.db.profile.assignments[playerName] ) then

		return 0

	end

	

	local total = 0

	for assignment, token in pairs(PaladinBuffer.db.profile.assignments[playerName]) do

		if( token == spellToken ) then

			total = total + 1

		end

	end

	

	return total

end





function Assign:FindSingleBlesser(spellToken)

	local highestName, highestRank

	for name, data in pairs(PaladinBuffer.db.profile.blessings) do

		if( data[spellToken] and ( not highestRank or highestRank < data[spellToken] ) ) then

			highestName = name

			highestRank = data[spellToken]

		end

	end

	

	return highestName

end



function Assign:IsBlessingAvailable(spellToken, playerName)

	if( playerName and PaladinBuffer.db.profile.blessings[playerName] ) then

		return PaladinBuffer.db.profile.blessings[playerName][spellToken] and true or false

	end



	for _, data in pairs(PaladinBuffer.db.profile.blessings) do

		if( data[spellToken] ) then

			return true

		end

	end

	

	return false

end



function Assign:IsGreaterAssigned(class, spellToken)

	for _, data in pairs(PaladinBuffer.db.profile.assignments) do

		if( data[class] == singleToGreater[spellToken] ) then

			return true

		end

	end

	

	return false

end