Module:Items/UseTables

Documentation for this module may be created at Module:Items/UseTables/doc

local p = {}

local Constants = require('Module:Constants')
local Common = require('Module:Common')
local Shared = require('Module:Shared')
local GameData = require('Module:GameData')
local SkillData = GameData.skillData
local Modifiers = require('Module:Modifiers')
local Skills = require('Module:Skills')
local Magic = require('Module:Magic')
local Areas = require('Module:CombatAreas')
local Items = require('Module:Items')
local Icons = require('Module:Icons')
local Agility = require('Module:Skills/Agility')
local Shop = require('Module:Shop')
local Num = require('Module:Number')

--Brute forcing some item uses to make things easier
local itemUseArray = {
	Agility = {},
	Astrology = {'melvorF:Stardust', 'melvorF:Golden_Stardust', 'melvorItA:Abyssal_Stardust', 'melvorItA:Eternal_Stardust'},
	Archaeology = {},
	Attack = {},
	Cartography = {},
	Combat = {'melvorF:Gold_Emerald_Ring', 'melvorD:Obsidian_Cape', 'melvorF:Throwing_Power_Gloves'},
	Cooking = {'melvorD:Cooking_Gloves'},
	Crafting = {'melvorItA:Abyssal_Crafting_Gloves'},
	Defence = {},
	Farming = {'melvorD:Compost', 'melvorD:Weird_Gloop', 'melvorItA:Abyssal_Compost', 'melvorD:Bobs_Rake'},
	Firemaking = {'melvorItA:Abyssal_Firemaking_Gloves'},
	Fishing = {'melvorD:Message_In_A_Bottle', 'melvorD:Barbarian_Gloves'},
	Fletching = {'melvorItA:Abyssal_Fletching_Gloves'},
	Harvesting = {'melvorItA:Abyssal_Harvesting_Gloves'},
	Herblore = {'melvorItA:Abyssal_Herblore_Gloves'},
	Hitpoints = {},
	Magic = {},
	Mining = {'melvorD:Mining_Gloves', 'melvorD:Gem_Gloves', 'melvorItA:Abyssal_Mining_Gloves'},
	Prayer = {},
	Ranged = {},
	Runecrafting = {'melvorItA:Abyssal_Runecrafting_Gloves'},
	Slayer = {},
	Smithing = {'melvorD:Smithing_Gloves', 'melvorItA:Abyssal_Smithing_Gloves'},
	Smithing = {},
	Strength = {},
	Summoning = {},
	Thieving = {'melvorF:Thieving_Gloves'},
	Township = {},
	Woodcutting = {},
}

-- List of modifier IDs which, if present on an item and not specific to any
-- particular skill, indicate that the item applies to all skills
local allSkillModIDs = {
	-- Skill XP
	'skillXP',
	'nonCombatSkillXP',
	'abyssalSkillXP',
	-- Mastery
	'flatMasteryTokens',
	'xpFromMasteryTokens',
	'masteryPoolCap',
	'masteryXP',
	'masteryPoolProgress',
	-- Resource preservation
	'bypassGlobalPreservationChance',
	'skillPreservationChance',
	'skillPreservationCap',
	-- Other preservation (consumables, summons, potion charges)
	'consumablePreservationChance',
	'summoningChargePreservationChance',
	'potionChargePreservationChance',
	-- Item doubling
	'globalItemDoublingChance',
	-- Resource quantity
	'flatBasePrimaryProductQuantity',
	'basePrimaryProductQuantity',
	'flatBaseRandomProductQuantity',
	'flatAdditionalSkillItem',
	'flatAdditionalPrimaryProductQuantity',
	-- Cost reduction
	'skillCostReduction',
	-- Off item chance
	'offItemChance'
}

local function allSkillModCriteriaFromIDs(modIDs)
	local modIDsWithProps = {}
	for i, modID in ipairs(allSkillModIDs) do
		table.insert(modIDsWithProps, {
			["id"] = modID,
			["type"] = 'id',
			["props"] = {
				["skillID"] = 'nil',
				["modType"] = 'pos'
			}
		})
	end
	return Modifiers.getMatchCriteriaFromIDs(modIDsWithProps)
end

local allSkillModCriteria = allSkillModCriteriaFromIDs(allSkillModIDs)

function p._getItemUses(item, asList, addCategories)
	-- Another fun one. This time getting all the different possible ways an item can be used
	local categoryArray = {}
	local skillUses = {}
	local otherUses = {}
	local otherUseText = {
		["Combat"] = Icons.Icon({'Combat'}),
		["Upgrade"] = '[[Upgrading Items]]',
		["Food"] = '[[Food]]',
		["Chest"] = '[[Chest|Can Be Opened]]',
		["Mastery"] = Icons.Icon({'Mastery'}),
		["AllSkills"] = 'All skills',
		["AltMagic"] = Icons.Icon({'Alt. Magic', type='skill'}),
		["ChargeStone"] = 'Powering ' .. Icons.Icon({'Crown of Rhaelyx', type='item'}),
		["Shop"] = Icons.Icon({'Shop'}),
		["TownshipTask"] = Icons.Icon({'Tasks', type='township'})
	}

	local addUse = function(useName)
		local skillID = Constants.getSkillID(useName)
		if skillID == nil then
			-- May have been passed a skill ID instead
			local skillName = Constants.getSkillName(useName)
			if skillName ~= nil then
				skillID = useName
				skillUses[skillID] = skillName
			end
		else
			skillUses[skillID] = useName
		end

		if skillID == nil and not otherUses[useName] then
			otherUses[useName] = true
		end
	end
	local hasUse = function(useName)
		local skillID = Constants.getSkillID(useName)
		if skillID == nil and Constants.getSkillName(useName) ~= nil then
			skillID = useName
		end
		if skillID ~= nil then
			return (skillUses[skillID] ~= nil) or false
		else
			return otherUses[useName] or false
		end
	end

	-- Check for any overrides within itemUseArray
	for useName, itemList in pairs(itemUseArray) do
		if Shared.contains(itemList, item.id) then
			addUse(useName)
		end
	end

	-- If the item has any modifiers that affect a given skill, add it to those tables
	-- Added special handling for Mastery Tokens since they were being incorrectly flagged as usable for all skills
	if item.modifiers ~= nil then
		if item.modifiers.masteryToken ~= nil then
			-- Mastery tokens
			addUse('Mastery')
		else
			local modsAllSkills = Modifiers.getMatchingModifiers(item.modifiers, allSkillModCriteria)
			if not Shared.tableIsEmpty(modsAllSkills.matched) then
				addUse('AllSkills')
			else
				local skillArray = Modifiers.getModifierSkills(item.modifiers)
				for i, skillName in ipairs(skillArray) do
					addUse(skillName)
				end
			end
		end
		if item.modifiers.thievingStealth ~= nil then
			addUse('melvorD:Thieving')
		end
	end

	--First things added to the list are non-skill things that are easy to check
	if not hasUse('Combat') and (Items.hasCombatStats(item) or item.specialAttacks ~= nil) then
		addUse('Combat')
	end

	-- Check if the item is an entry requirement for any Slayer area
	if not hasUse('Slayer') and (item.validSlots ~= nil or item.occupiesSlots ~= nil or item.equipmentStats ~= nil) then
		local slayerAreas = Areas.getAreas(function(area) return area.type == 'slayerArea' and type(area.entryRequirements) == 'table' end)
		for i, area in ipairs(slayerAreas) do
			for j, req in ipairs(area.entryRequirements) do
				if req.type == "SlayerItem" and req.itemID == item.id then
					addUse('Slayer')
					break
				end
			end
			if hasUse('Slayer') then
				break
			end
		end
	end

	-- Is the item a cost in an upgrade?
	for i, upgrade in ipairs(GameData.rawData.itemUpgrades) do
		for j, itemCost in ipairs(upgrade.itemCosts) do
			if itemCost.id == item.id then
				addUse('Upgrade')
				table.insert(categoryArray, '[[Category:Upgradeable Items]]')
				break
			end
		end
		if hasUse('Upgrade') then
			break
		end
	end

	if item.healsFor ~= nil then
		table.insert(categoryArray, '[[Category:Food Items]]')
		addUse('Food')
	end

	if item.dropTable ~= nil then
		table.insert(categoryArray, '[[Category:Openable Items]]')
		addUse('Chest')
	end

	-- Cooking, Smithing, Fletching, Crafting, Runecrafting, Herblore
	-- All have somewhat consistent recipe data structures
	local recipeSkillIDs = {
		'melvorD:Cooking',
		'melvorD:Smithing',
		'melvorD:Fletching',
		'melvorD:Crafting',
		'melvorD:Runecrafting',
		'melvorD:Herblore'
	}
	for i, recipeSkillID in ipairs(recipeSkillIDs) do
		if not hasUse(recipeSkillID) then
			local _, localSkillID = GameData.getLocalID(recipeSkillID)
			-- Iterate over all recipes for the current skill
			for j, recipe in ipairs(SkillData[localSkillID].recipes) do
				for k, itemCost in ipairs(recipe.itemCosts) do
					if itemCost.id == item.id then
						addUse(recipeSkillID)
						break
					end
				end
				-- Some items (such as Arrow shafts) have multiple recipes
				if not hasUse(recipeSkillID) and type(recipe.alternativeCosts) == 'table' then
					for k, altCost in ipairs(recipe.alternativeCosts) do
						for m, itemCost in ipairs(altCost.itemCosts) do
							if itemCost.id == item.id then
								addUse(recipeSkillID)
								break
							end
						end
						if hasUse(recipeSkillID) then
							break
						end
					end
				end
				if hasUse(recipeSkillID) then
					break
				end
			end
		end
	end

	-- Firemaking
	if not hasUse('melvorD:Firemaking') then
		for i, recipe in ipairs(SkillData.Firemaking.logs) do
			if recipe.logID == item.id then
				addUse('melvorD:Firemaking')
				break
			end
		end
	end

	-- Farming
	if not hasUse('melvorD:Farming') then
		for i, recipe in ipairs(SkillData.Farming.recipes) do
			if recipe.seedCost.id == item.id then
				addUse('melvorD:Farming')
				break
			end
		end
	end

	-- Agility
	if not hasUse('melvorD:Agility') and not Shared.tableIsEmpty(Agility.getObstaclesForItem(item.id)) then
		addUse('melvorD:Agility')
	end

	-- Summoning
	if not hasUse('melvorD:Summoning') then
		for i, recipe in ipairs(SkillData.Summoning.recipes) do
			-- Tablets & Non-shard items
			if recipe.productID == item.id or Shared.contains(recipe.nonShardItemCosts, item.id) then
				addUse('melvorD:Summoning')
				break
			else
				-- Shards
				for j, itemCost in ipairs(recipe.itemCosts) do
					if itemCost.id == item.id then
						addUse('melvorD:Summoning')
						break
					end
				end
			end
		end
	end

	-- Prayer
	if item.prayerPoints ~= nil then
		table.insert(categoryArray, '[[Category:Buriable Items]]')
		if not hasUse('melvorD:Prayer') then
			addUse('melvorD:Prayer')
		end
	elseif item.soulPoints ~= nil then
		table.insert(categoryArray, '[[Category:Releasable Items]]')
		if not hasUse('melvorD:Prayer') then
			addUse('melvorD:Prayer')
		end
	end

	-- Magic
	if not (hasUse('Magic') and hasUse('AltMagic')) then
		-- First check if the item its self is used in any spells
		local spellList = Magic.getSpellsUsingItem(item.id, true)
		for i, spell in ipairs(spellList) do
			local useKey = (spell.type == 'altMagic' and 'AltMagic' or 'Magic')
			if not hasUse(useKey) then
				addUse(useKey)
			end
		end
		-- Check if the item provides runes, if it does check where they are used also
		if item.providedRunes ~= nil then
			for i, rune in ipairs(item.providedRunes) do
				if hasUse('Magic') and hasUse('AltMagic') then
					break
				else
					local spellList = Magic.getSpellsUsingItem(rune.id, false)
					for j, spell in ipairs(spellList) do
						local useKey = (spell.type == 'altMagic' and 'AltMagic' or 'Magic')
						if not hasUse(useKey) then
							addUse(useKey)
						end
					end
				end
			end
		end
	end

	-- Other odds and ends:

	-- Skillcapes are tied to the appropriate skill
	-- Except Maximum Skillcape, which is tied to all skills. (And so is the Signet Ring)
	-- And combat skillcapes, since combat skills don't get special treatment
	if item.tier == 'Skillcape' then
		local ignoreCapes = {
			'melvorD:Attack_Skillcape',
			'melvorD:Strength_Skillcape',
			'melvorD:Defence_Skillcape',
			'melvorD:Hitpoints_Skillcape',
			'melvorF:Ranged_Skillcape',
			'melvorTotH:Superior_Attack_Skillcape',
			'melvorTotH:Superior_Strength_Skillcape',
			'melvorTotH:Superior_Defence_Skillcape',
			'melvorTotH:Superior_Hitpoints_Skillcape',
			'melvorTotH:Superior_Ranged_Skillcape',
		}
		local allCapes = {
			'melvorF:Max_Skillcape',
			'melvorF:Cape_of_Completion',
			'melvorTotH:Superior_Max_Skillcape',
			'melvorTotH:Superior_Cape_Of_Completion',
		}
		if Shared.contains(allCapes, item.id) then
			addUse('AllSkills')
		elseif Shared.contains({'melvorF:Magic_Skillcape', 'melvorTotH:Superior_Magic_Skillcape'}, item.id) then
			addUse('melvorD:Magic')
			addUse('AltMagic')
		elseif not Shared.contains(ignoreCapes, item.id) then
			local splitName = Shared.splitString(item.name, ' ')
			local skillName = (splitName[1] == 'Superior' and splitName[2]) or splitName[1]
			addUse(skillName)
		end
		table.insert(categoryArray, '[[Category:Skillcapes]]')
	end
	
	--Special note for Charge Stone of Rhaelyx
	if item.id == 'melvorD:Charge_Stone_of_Rhaelyx' then
		addUse('ChargeStone')
	end

	--Some items are needed to make shop purchases
	local shopArray = Shop.getItemCostArray(item.id)
	if not Shared.tableIsEmpty(shopArray) then
		addUse('Shop')
	end

	-- Township Tasks
	for _, task in ipairs(SkillData.Township.tasks) do
		if task.goals.items ~= nil then -- Skip tasks with no items
			if GameData.getEntityByID(task.goals.items, item.id) then
				addUse('TownshipTask')
				break
			end
		end
	end
	
	-- Generate result text
	local useArray = {}
	local prefix, delim = asList and '* ' or '', asList and '\r\n' or '<br/>'
	-- Always place 'All skills' use before any skills
	if hasUse('AllSkills') then
		table.insert(useArray, prefix .. (otherUseText.AllSkills or 'AllSkills'))
		otherUses.AllSkills = nil
	end
	for skillID, skillName in Shared.spairs(skillUses, function(t, a, b) return t[a] < t[b] end) do
		table.insert(useArray, prefix .. Icons.Icon({skillName, type='skill'}))
	end
	for use, _ in Shared.skpairs(otherUses) do
		table.insert(useArray, prefix .. (otherUseText[use] or use))
	end

	return table.concat(useArray, delim) .. (addCategories and table.concat(categoryArray, '') or '')
end

function p.getItemUses(frame)
	local itemName = frame.args ~= nil and frame.args[1] or frame
	local item = Items.getItem(itemName)
	local addCategories = false
	local asList = true
	if frame.args ~= nil then
		addCategories = frame.args.addCategories ~= nil and frame.args.addCategories ~= '' and frame.args.addCategories ~= 'false'
		asList = frame.args.addCategories == nil or frame.args.addCategories == '' or frame.args.addCategories == 'true'
	end
	if item == nil then
		return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
	end

	return p._getItemUses(item, asList, addCategories)
end

function p._getItemUseTable(item)
	local tableData = {}

	-- Loop through all upgrades to find anything that can be upgraded using our source
	for i, upgrade in ipairs(GameData.rawData.itemUpgrades) do
		for j, itemCost in ipairs(upgrade.itemCosts) do
			if itemCost.id == item.id then
				local reqs = nil
				-- Potions do have upgrade requirements though
				local upgradeItem = Items.getItemByID(upgrade.upgradedItemID)
				if upgradeItem ~= nil and upgradeItem.charges ~= nil and upgradeItem.tier ~= nil then
					local levelUnlock = GameData.getEntityByProperty(SkillData.Herblore.masteryLevelUnlocks, 'descriptionID', upgradeItem.tier + 1)
					if levelUnlock ~= nil then
						reqs = Icons._MasteryReq(upgradeItem.name, levelUnlock.level)
					end
				end
				table.insert(tableData, {
					['skill'] = 'Upgrade',
					['useType'] = '[[Upgrading Items|' .. (upgrade.isDowngrade and 'Downgrade' or 'Upgrade') .. ']]',
					['reqs'] = reqs,
					['costs'] = Common.getCostString({ ["items"] = upgrade.itemCosts, ["currencies"] = upgrade.currencyCosts }),
					['productName'] = upgradeItem.name,
					['qty'] = (upgrade.quantity or 1)
				})
			end
		end
	end

	-- Cooking, Smithing, Fletching, Crafting, Runecrafting, Herblore
	-- All have somewhat consistent recipe data structures
	local recipeSkillIDs = {
		'melvorD:Cooking',
		'melvorD:Smithing',
		'melvorD:Fletching',
		'melvorD:Crafting',
		'melvorD:Runecrafting',
		'melvorD:Herblore'
	}
	for i, recipeSkillID in ipairs(recipeSkillIDs) do
		local skillName = Constants.getSkillName(recipeSkillID)
		local _, localSkillID = GameData.getLocalID(recipeSkillID)
			
		-- Iterate over all recipes for the current skill
		for j, recipe in ipairs(SkillData[localSkillID].recipes) do
			local costLists = {recipe.alternativeCosts or {}, {{["itemCosts"] = recipe.itemCosts}}}
			for k, costList in pairs(costLists) do
				for m, costDef in pairs(costList) do
					for n, itemCost in ipairs(costDef.itemCosts) do
						if itemCost.id == item.id then
							local recipeItemIDs = nil
							if recipeSkillID == 'melvorD:Herblore' then
								recipeItemIDs = recipe.potionIDs
							elseif recipeSkillID == 'melvorD:Cooking' then
								recipeItemIDs = {recipe.productID, recipe.perfectCookID}
							else
								recipeItemIDs = {recipe.productID}
							end
							for o, recipeItemID in ipairs(recipeItemIDs) do
								local recipeItem = Items.getItemByID(recipeItemID)
								if recipeItem ~= nil then
									local lvl, isAbyssal = Skills.getRecipeLevelRealm(recipeSkillID, recipe)
									local reqs = nil
									if recipeSkillID == 'melvorD:Cooking' then
										-- Cooking includes the required utility (fire, furnace, pot) as a special requirement
										local cookingCatIcon = {
											["melvorD:Fire"] = 'Normal Cooking Fire',
											["melvorD:Furnace"] = 'Basic Furnace',
											["melvorD:Pot"] = 'Basic Pot'
										}
										local categoryIconName, categoryName = cookingCatIcon[recipe.categoryID], nil
										local recipeCategory = GameData.getEntityByID(SkillData.Cooking.categories, recipe.categoryID)
										if recipeCategory ~= nil then
											categoryName = recipeCategory.modifierName or recipeCategory.name
										end
										if categoryIconName ~= nil and categoryName ~= nil then
											local utilReq = Icons.Icon({'Cooking', categoryName, section = 'Cooking Upgrades', img = categoryIconName, type = 'upgrade'})
											reqs = Icons._SkillReq(skillName, lvl, false, (isAbyssal and "melvorItA:Abyssal" or nil)) .. '<br>' .. utilReq
										end
									elseif recipeSkillID == 'melvorD:Herblore' then
										-- Herblore may also have a mastery requirement
										local levelUnlock = GameData.getEntityByProperty(SkillData.Herblore.masteryLevelUnlocks, 'descriptionID', recipeItem.tier + 1)
										if levelUnlock ~= nil and levelUnlock.level > 1 then
											local masteryReq = Icons._MasteryReq(recipeItem.name, levelUnlock.level)
											reqs = Icons._SkillReq(skillName, lvl, false, (isAbyssal and "melvorItA:Abyssal" or nil)) .. '<br>' .. masteryReq
											-- Slightly increase level per potion tier for proper ordering using data-sort-value
											lvl = lvl + levelUnlock.level * 0.01
										end
									end
									table.insert(tableData, {
										['skill'] = skillName,
										['lvl'] = lvl,
										['isAbyssal'] = isAbyssal,
										['useType'] = Icons.Icon({skillName, type='skill'}),
										['reqs'] = (reqs or Icons._SkillReq(skillName, lvl, false, (isAbyssal and "melvorItA:Abyssal" or nil))),
										['costs'] = Common.getCostString({ ["items"] = costDef.itemCosts, ["currencies"] = recipe.currencyCosts }),
										['productName'] = recipeItem.name,
										['qty'] = (recipe.baseQuantity or 1) * (costDef.quantityMultiplier or 1),
										['xp'] = recipe.baseAbyssalExperience or recipe.baseExperience
									})
								end
							end
							break
						end
					end
				end
			end
		end
	end

	-- Farming
	for i, recipe in ipairs(SkillData.Farming.recipes) do
		if recipe.seedCost.id == item.id then
			local category = GameData.getEntityByID(SkillData.Farming.categories, recipe.categoryID)
			local lvl, isAbyssal = Skills.getRecipeLevelRealm('melvorD:Farming', recipe)
			local product = Items.getItemByID(recipe.productId)

			table.insert(tableData, {
				['skill'] = 'Farming',
				['lvl'] = lvl,
				['isAbyssal'] = isAbyssal,
				['useType'] = Icons.Icon({'Farming', type='skill'}),
				['reqs'] = Icons._SkillReq('Farming', lvl, false, (isAbyssal and 'melvorItA:Abyssal' or nil)),
				['costs'] = { recipe.seedCost },
				['productName'] = product.name,
				['qty'] = (5 * category.harvestMultiplier),
				['xp'] = recipe.baseAbyssalExperience or recipe.baseExperience
			})
		end
	end

	-- Agility
	local obstacles = Agility.getObstaclesForItem(item.id)
	for i, obstacle in ipairs(obstacles) do
		table.insert(tableData, {
			['skill'] = 'Agility',
			['lvl'] = Skills.getRecipeLevelRealm('Agility', obstacle),
			['isAbyssal'] = obstacle.realm == 'melvorItA:Abyssal',
			['useType'] = Icons.Icon({'Agility', type='skill'}),
			['reqs'] = Agility._getObstacleRequirements(obstacle),
			['costs'] = Common.getCostString({ ["items"] = obstacle.itemCosts, ["currencies"] = obstacle.currencyCosts }),
			['productName'] = obstacle.name,
			['iconType'] = 'agility',
			['qty'] = 1
		})
	end

	-- Summoning
	for i, recipe in ipairs(SkillData.Summoning.recipes) do
		local recipeCost = 0
		if recipe.abyssalLevel ~= nil then
			recipeCost = SkillData.Summoning.recipeAPCost
		else
			recipeCost = SkillData.Summoning.recipeGPCost
		end
		local useShards = false
		local recipeItem = nil
		for j, itemCost in ipairs(recipe.itemCosts) do
			if itemCost.id == item.id then
				useShards = true
				break
			end
		end
		-- Non-shard items
		-- Familiar recipes may also have a currency cost without any non-shard
		-- items, so account for this with a dummy ID such that one iteration
		-- of the below loop always occurs
		local nonShardItemIDs = (Shared.tableIsEmpty(recipe.nonShardItemCosts) and {''} or recipe.nonShardItemCosts)
		for j, nonShardItemID in ipairs(nonShardItemIDs) do
			if useShards or nonShardItemID == item.id then
				-- Item is used in this particular synergy recipe
				if recipeItem == nil then
					recipeItem = Items.getItemByID(recipe.productID)
				end
				local nonShardItem = Items.getItemByID(nonShardItemID)
				local recipeCosts = Shared.clone(recipe.itemCosts)
				local xp = recipe.baseAbyssalExperience or recipe.baseExperience
				local lvl, isAbyssal = Skills.getRecipeLevelRealm('melvorD:Summoning', recipe)
				local recipeCosts = {}
				for k, itemCost in ipairs(recipe.itemCosts) do
					table.insert(recipeCosts, {id = itemCost.id, quantity = itemCost.quantity})
				end
				if nonShardItem ~= nil then
					-- Item ID can be nil for recipes such as Leprechaun or Cyclops
					local itemValue = math.max(nonShardItem.sellsFor, 20)
					local nonShardQty = math.max(1, math.ceil(recipeCost / itemValue))
					table.insert(recipeCosts, { id = nonShardItemID, quantity = nonShardQty })
				end
				table.insert(tableData, {
					['skill'] = 'Summoning',
					['lvl'] = lvl,
					['isAbyssal'] = isAbyssal,
					['useType'] = Icons.Icon({ 'Summoning', type='skill' }),
					['reqs'] = Icons._SkillReq('Summoning', lvl, false, (isAbyssal and 'melvorItA:Abyssal' or nil)),
					['costs'] = Common.getCostString({ ["items"] = recipeCosts, ["currencies"] = recipe.currencyCosts }),
					['productName'] = recipeItem.name,
					['qty'] = recipe.baseQuantity,
					['xp'] = xp
				})
			end
		end
	end

	--Handle shop purchases using Module:Shop
	local shopUses = Shop.getItemCostArray(item.id)
	for i, shopUse in ipairs(shopUses) do
		local purchase = shopUse.purchase

		table.insert(tableData, {
			['skill'] = 'Shop',
			['lvl'] = (not Shared.tableIsEmpty(purchase.purchaseRequirements) and purchase.purchaseRequirements[1].level or nil),
			['useType'] = Icons.Icon({'Shop'}),
			['reqs'] = Common.getRequirementString(purchase.purchaseRequirements),
			['costs'] = Common.getCostString(purchase.cost),
			['productName'] = Common.getPurchaseName(purchase),
			['iconType'] = Common.getPurchaseIconType(purchase),
			['qty'] = (purchase.qty or 1)
		})
	end

	--Finally build the table using what we've learned
	table.sort(tableData, function(a, b)
		local aLvl = a.lvl
		local bLvl = b.lvl
		if a.skill ~= b.skill then
			return a.skill < b.skill
		elseif type(aLvl) ~= type(bLvl) then
			return tostring(aLvl) < tostring(bLvl)
		elseif aLvl ~= bLvl then
			return aLvl < bLvl
		else
			return a.productName < b.productName
		end
	end)

	local useTable = p.buildUseTable(item, tableData)

	local spellUseTable = p._getSpellUseTable(item)
	if spellUseTable ~= nil and spellUseTable ~= '' then
		useTable = useTable .. '\r\n===' .. Icons.Icon({'Magic', type='skill', size=30}) .. '===\r\n' .. spellUseTable
	end
	if useTable == '' then
		return ''
	else
		return '==Uses==\r\n' .. useTable
	end
end

function p.buildUseTable(item, tableData)
	if Shared.tableIsEmpty(tableData) then return '' end

	local showRequirements = false
	local showXP = false

	for i, data in ipairs(tableData) do
		if not showRequirements and tableData[i].reqs ~= nil then showRequirements = true end
		if not showXP and tableData[i].xp ~= nil then showXP = true end
		if showRequirements and showXP then break end
	end

	local resultTable = mw.html.create('table')
	resultTable:addClass('wikitable stickyHeader sortable col-1-img')
	local tableHeader = resultTable:tag('tr'):addClass('headerRow-0')
		:tag('th'):wikitext('Product'):attr('colspan', 2)
		:tag('th'):wikitext('Used In')

	if showRequirements then tableHeader:tag('th'):wikitext('Requires') end
	if showXP then tableHeader:tag('th'):wikitext('Exp') end
	tableHeader:tag('th'):wikitext('Costs')

	for i, data in ipairs(tableData) do
		local recipeRow = resultTable:tag('tr')
			:tag('td'):wikitext(Icons.Icon({ data.productName, type=(data.iconType or 'item'), notext=true })):attr('data-sort-value', data.productName) -- Icon Image
			:tag('td')
				:wikitext((data.qty ~= nil and data.qty > 1 and ("'''" .. data.qty .. "x''' ") or '')) -- Icon Qty
				:wikitext(Icons.Icon({ data.productName, type=(data.iconType or 'item'), noicon=true })) -- Icon Text
			:tag('td'):wikitext(data.useType):attr('data-sort-value', (data.skill or nil)) -- Used In
		-- Requirements
		if showRequirements then
			if data.reqs ~= nil then
				recipeRow:tag('td'):wikitext(data.reqs):attr('data-sort-value', (data.lvl or 0))
			else
				recipeRow:tag('td'):wikitext('N/A'):addClass('table-na')
			end
		end
		-- Exp
		if showXP then
			if data.skill ~= nil and data.xp ~= nil then
				local iconClass = (data.isAbyssal and 'abyss-icon' or nil)
				local xpText = (data.isAbyssal and ' AXP' or ' XP')
				recipeRow:tag('td'):attr('data-sort-value', data.xp)
					:wikitext(Icons.Icon({ data.skill, notext=true, type='skill', class=iconClass }))
					:wikitext(' ' .. Num.formatnum(data.xp) .. xpText)
			else
				recipeRow:tag('td'):wikitext('N/A'):addClass('table-na'):attr('data-sort-value', 0)
			end
		end
		-- Costs
		local costsRow = recipeRow:tag('td')
		if type(data.costs) == 'table' then
			for i, mat in ipairs(data.costs) do
				if i > 1 then costsRow:tag('br') end
				local matItem = Items.getItemByID(mat.id)
				if matItem == nil then
					costsRow:wikitext(mat.quantity .. 'x ?????')
				else
					costsRow:wikitext(Icons.Icon({ matItem.name, type='item', qty=mat.quantity }))
				end
			end
		else
			costsRow:wikitext(data.costs)
		end
	end

	return tostring(resultTable)
end

function p.getItemUseTable(frame)
	local itemName = frame.args ~= nil and frame.args[1] or frame
	local item = Items.getItem(itemName)
	if item == nil then
		return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
	end

	return p._getItemUseTable(item)
end

function p._getSpellUseTable(item)
	local spellList = Magic.getSpellsUsingItem(item.id, true)
	--Bail immediately if no spells are found
	if Shared.tableIsEmpty(spellList) then
		return ''
	end

	--Adding a check for if the Items column is needed
	local hasItems = false
	for i, spell in pairs(spellList) do
		if Magic._getSpellItems(spell) ~= '' then
			hasItems = true
			break
		end
	end

	local resultPart = {}
	table.insert(resultPart, '{|class="wikitable sortable"\r\n!colspan="2"|Spell')
	table.insert(resultPart, '!!Requires')
	table.insert(resultPart, '!!Type!!style="width:275px"|Description')
	table.insert(resultPart, '!!Runes')
	if hasItems then
		table.insert(resultPart, '!!Item Cost')
	end

	for i, spell in pairs(spellList) do
		local spellBook = Magic.getSpellBookFromSpell(spell)
		local rowPart = {}
		table.insert(rowPart, '\r\n|-\r\n|data-sort-value="'..spell.name..'"|')
		local iconType = Magic._getSpellIconType(spell)
		table.insert(rowPart, Icons.Icon({spell.name, type=iconType, notext=true}))
		table.insert(rowPart, '||'..Icons.Icon({spell.name, type=iconType, noicon=true}))
		table.insert(rowPart, '||data-sort-value="'..Skills.getRecipeLevel('melvorD:Summoning', spell)..'"|'..Magic._getSpellRequirements(spell))
		table.insert(rowPart, '||data-sort-value="'.. spellBook.id ..'"|')
		table.insert(rowPart, Magic.getSpellTypeLink(spellBook.id))
		table.insert(rowPart, '||'..Magic._getSpellStat(spell, 'description'))
		table.insert(rowPart, '||style="text-align:center"|')
		table.insert(rowPart, Magic._getSpellRunes(spell))
		if hasItems then
			table.insert(rowPart, '||')
			table.insert(rowPart, Magic._getSpellItems(spell))
		end
		table.insert(resultPart, table.concat(rowPart))
	end
	 --Add the table end and add the table to the result string
	table.insert(resultPart, '\r\n|}')
	return table.concat(resultPart)
end

function p.getSpellUseTable(frame)
	local itemName = frame.args ~= nil and frame.args[1] or frame
	local item = Items.getItem(itemName)
	if item == nil then
		return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
	end

	return p._getSpellUseTable(item)
end

--[[
-- Uncomment this block and execute 'p.test()' within the debug console
-- to test after making changes
function p.test()
	local checkItems = {
		'Gold Bar',
		'Raw Shrimp',
		'Coal Ore',
		'Rune Platebody',
		'Arrow Shafts',
		'Garum Seeds',
		'Rune Essence',
		'Runite Bar',
		'Water Rune',
		'Steam Rune',
		'Controlled Heat Potion II',
		'Wolf',
		'Cyclops',
		'Leprechaun',
		'Redwood Logs',
		'Carrot Cake',
		'Carrot Cake (Perfect)',
		'Mantalyme Herb',
		'Carrot',
		'Topaz',
		'Rune Essence',
		'Infernal Claw',
		'Chapeau Noir',
		'Stardust',
		'Rope',
		'Ancient Ring of Mastery',
		'Mysterious Stone',
		'Charge Stone of Rhaelyx',
		'Mastery Token (Cooking)',
		'Gem Gloves',
		'Basic Bag',
		'Bird Nest',
		'Abyssal Stone',
		'Withered Ash',
		'Wrath Rune',
		'Magic Bones',
		'Bowstring',
		'Superior Max Skillcape',
		'Abyssal Coin Contract II',
		'Dark Summon Consumable II',
		'Abyssal Slayer Gear Upgrade Kit',
		'Topaz Bolts (Enchanted)',
		'Summoning Shard (Black)',
		'Dragon Javelin',
	}
	local checkFuncs = {
		--p.getItemUses,
		p.getItemUseTable
	}
	local errCount = 0
	for i, item in ipairs(checkItems) do
		local param = {args={item}}
		mw.log('=' .. item .. '=')
		for j, func in ipairs(checkFuncs) do
			local callSuccess, retVal = pcall(func, param)
			if not callSuccess then
				errCount = errCount + 1
				mw.log('Error with item "' .. item .. '": ' .. retVal)
			else
				mw.log(retVal)
			end
		end
	end
	if errCount == 0 then
		mw.log('Test successful')
	else
		mw.log('Test failed with ' .. errCount .. ' failures')
	end
end
--]]

return p