Module:Calculator/AgilityObstacle

Documentation for this module may be created at Module:Calculator/AgilityObstacle/doc

local p = {}

local Constants = require('Module:Constants')
local Agility = require('Module:Skills/Agility')
local Shared = require('Module:Shared')
local Icons = require('Module:Icons')
local Debug = require('Module:Debug') -- Comment out when Module is finalised.

local function getItemIcon(itemName, amount)
	if itemName == 'GP' then
		return Icons.GP(amount)
	end
	
	if itemName == 'SC' then
		return Icons.SC(amount)
	end
	
	return Icons.Icon({itemName, type='item', qty = amount, notext=true})
end

-- Gets all associated metadata from an obstacle based on its name.
local function getObstacle(name)
	name = Shared.specialTitleCase(name)
	local obstacle = Agility.getObstacle(name) or Agility.getPillar(name)
	if obstacle == nil then
		error("Unknown Agility obstacle or pillar name: " .. name)
	end

	-- Resolve obstacle slot.
	local slot = 0
	if string.find(name, 'Pillar') then
		if string.find(name, 'Elite') then
			slot = 'Elite Pillar'
		else
			slot = 'Pillar'
		end
	else
		slot = obstacle.category + 1
	end
	
	local obstacleInfo = {
		Name = obstacle.name,
		Slot = slot,
		Obstacle = obstacle,
		LevelRequirements = Agility.getObstacleRequirements(obstacle),
		ItemCosts = Agility.getObstacleCosts(obstacle),
	}

	return obstacleInfo
end

function p.calculateCourse(obstacleNames, checkDoubleSlots)
	-- Collect all obstacles and filter out nill values.
	local courseObstacles = {}
	local courseSlots = {}
	
	for _, v in pairs(obstacleNames) do
		local currObstacle = getObstacle(v)
		if currObstacle then
			if checkDoubleSlots and courseSlots[currObstacle.Slot] == true then
				error('There are two or more obstacles in the same slot. Obstacle: ' .. currObstacle.Name .. ' Slot: ' .. currObstacle.Slot)
			end
			
			courseSlots[currObstacle.Slot] = true
			table.insert(courseObstacles, currObstacle) 
		end
	end
	
	-- Calculate the highest level requirements and the total amount of items
	-- required to build this agility course.
	local courseLevelRequirements = {}
	local courseItemCosts = {}
	
	for _, course in pairs(courseObstacles) do
		for skill, level in pairs(course.LevelRequirements) do
				Shared.addOrUpdate(courseLevelRequirements, skill, 
					function(x)	
						if x then return math.max(x, level)	else return level end 
					end)
		end
		
		for item, amount in pairs(course.ItemCosts) do
				Shared.addOrUpdate(courseItemCosts, item, 
					function(x)
						x = x or 0 return x + amount
					end)
		end
	end

	-- Sort course on category
	local sortFunc = function(a, b)
		-- Special case to sort pillars AFTER all regular obstacles.
    	local pillar = { ["Pillar"] = 99, ["Elite Pillar"] = 100 }
		return (pillar[a.Slot] or a.Slot) < (pillar[b.Slot] or b.Slot)
	end
	
	table.sort(courseObstacles, sortFunc)
	
	return {
		Obstacles = courseObstacles,
		CourseLevelRequirements = courseLevelRequirements,
		CourseItemCosts = courseItemCosts
	}
end

-- Stupid shenanigans to filter out numeric parameters.
-- Because just iterating over #args doesn't work for some reason...
function parseObstacleArgs(args)
	local obstacleNames = {}
	for k, v in pairs(args) do
		k = tonumber(k)
		if k then 
			table.insert(obstacleNames, v:match("^%s*(.-)%s*$")) 
		end
	end
	
	return obstacleNames
end

function p.getCourseList(frame)
	local args = frame:getParent().args
	return p._getCourseList(args)
end

function p._getCourseList(args)
	local obstacleNames = parseObstacleArgs(args)
	local courseRequirements = p.calculateCourse(obstacleNames, true)
	
	local includeItems = args['includeitems'] or true
	local includeSkills = args['includeskills'] or true
	local includeObstacles = args['includeObstacles'] or true
	
	local html = mw.html.create()
    local div = html:tag('div')
    
    if includeObstacles then
		div:tag('b'):wikitext('Obstacles')
		local tbl = mw.html.create("table")
        	:addClass("wikitable stickyHeader text-align-left")
        	
        tbl	:tag("tr")
        		:tag("th"):wikitext("Slot")
        		:tag("th"):wikitext("Obstacle")

		for _, v in pairs(courseRequirements.Obstacles) do
			tbl	:tag('tr')
					:tag('td')
						:css('text-align', 'right')
						:wikitext(v.Slot)
					:tag('td')
						:wikitext(Icons.Icon({v.Name, type='agility'}))
		end
		
		div:node(tbl)
		div:wikitext('<br>')
    end

    if includeItems then
    	div:tag('b'):wikitext('Items Required')
    	local ul = div:tag('ul')
    	
    	local itemList = Shared.sortDictionary(courseRequirements.CourseItemCosts, 
    		function(a, b) return a.item < b.item end,
    		function(a, b) return {item = a, amount = b} end)

		for _, v in pairs(itemList) do
    		ul:tag('li'):wikitext(getItemIcon(v.item, v.amount))
		end
		div:wikitext('<br>')
    end
	
	if includeSkills then
		div:tag('b'):wikitext('Skills Required')
    	local ul2 = div:tag('ul')
    	
    	local skillList = Shared.sortDictionary(courseRequirements.CourseLevelRequirements, 
    		function(a, b) return a.skill < b.skill end,
    		function(a, b) return {skill = a, level = b} end)
    	
    	for _, v in pairs(skillList) do
    		ul2:tag('li'):wikitext(Icons._SkillReq(v.skill, v.level))
    	end
    	div:wikitext('<br>')
	end
	
    return tostring(html)
end

function p.test()
	local obs = {'Elite Pillar of Conflict ', ' Cargo Net ',' Balance Beam','Pipe Climb'}
	local a = p._getCourseList(obs)
end

function p.getCourseTable(frame)
	local args = frame:getParent().args
	return p._getCourseTable(args)
end

function p._getCourseTable(args)
	--== Local Functions for formatting Obstacle MetaData ==--
	local function getBonusses(obstacle)
		local bonuses = {}
		for bonusName, bonusValue in pairs(obstacle.modifiers) do
			table.insert(bonuses, Constants._getModifierText(bonusName, bonusValue))
		end
		if Shared.tableIsEmpty(bonuses) then
			table.insert(bonuses, '<span style="color:red">None :(</span>')
		end
		return table.concat(bonuses, '<br/>')
	end
	
	local function getRequirements(requirementsTable)
		local skillList = Shared.sortDictionary(requirementsTable, 
			function(a, b) return a.skill < b.skill end,
			function(a, b) return {skill = a, level = b} end)
		
		local res = {}
		for _, v in pairs(skillList) do
			table.insert(res, Icons._SkillReq(v.skill, v.level))
		end
		return table.concat(res, '<br/>')
	end
	
	local function getCosts(costsTable)
		-- Order table with GP, SC first, then the other items.
	    local sortedCosts = {}
    	if costsTable['GP'] then table.insert(sortedCosts, {item = 'GP', amount = costsTable['GP']}) end
    	if costsTable['SC'] then table.insert(sortedCosts, {item = 'SC', amount = costsTable['SC']}) end
    	
    	for k, v in pairs(costsTable) do
    		if k ~= 'GP' and k ~= 'SC' then
    			table.insert(sortedCosts, {item = k, amount = v})
    		end
    	end
    	
    	local res = {}
    	for _, v in pairs(sortedCosts) do
    		table.insert(res, getItemIcon(v.item, v.amount))
    	end
		return table.concat(res, '<br/>')
	end
	
	
	--== Start of table formatting ==--
	local obstacleNames = parseObstacleArgs(args)
	local courseRequirements = p.calculateCourse(obstacleNames, true)

	local showTotals = args['showtotals'] or true

	local tbl = mw.html.create("table")
       	:addClass("wikitable stickyHeader")
       	
    tbl :tag('tr')
			:tag('th'):wikitext('Slot')
			:tag('th'):wikitext('Obstacle')
			:tag('th'):wikitext('Bonuses')
			:tag('th'):wikitext('Requirements')
			:tag('th'):wikitext('Costs')

	for _, obstacle in pairs(courseRequirements.Obstacles) do
		tbl :tag('tr')
				:tag('td'):wikitext(obstacle.Slot)
				:tag('td'):wikitext(Icons.Icon({obstacle.Name, type='agility'}))
				:tag('td'):wikitext(getBonusses(obstacle.Obstacle))
				:tag('td'):wikitext(getRequirements(obstacle.LevelRequirements))
				:tag('td'):wikitext(getCosts(obstacle.ItemCosts))
	end
	
	--local obstacleInfo = {
		--Name = obstacle.name,
		--Slot = slot,
		--Obstacle = obstacle,
		--LevelRequirements = Agility.getObstacleRequirements(obstacle),
		--ItemCosts = Agility.getObstacleCosts(obstacle),
	--}

	return tostring(tbl)
end

return p