Editing Module:Param Parse

--[=[
-- Standardized functions to parse Infobox params
--]=]
-- <nowiki>
require('strict')
local Infobox = require('Module:Infobox')
local currency = require('Module:Currency').parse

local parse = {}

-- Generic functions --
-----------------------

-- Standardized "has content" function
function parse.has_content(arg)
	-- Return arg if any non-whitespace character is found
	return string.match(arg or '', '%S') and arg or nil
end

-- Standardized numbers
function parse.number(num)
	num = string.gsub(num or '',',','')
	return tonumber(num)
end

-- Standardized number range: Accepts '1' and '1-5'
function parse.number_or_number_range(prenum)
	if not prenum then return end
	local ret = ''
	local count = 0
	for out in string.gmatch(prenum, "[^-]+") do 
		if count == 1 then
			ret = ret .. "➨\n"
		elseif count == 3 then
			return nil
		end
		local num = parse.number(out)
		if num == nil then
			return nil
		end
		ret = ret .. num
		count = count + 1
	end
	if count == 0 then
		return nil
	end
	return ret
end

function parse.number_or_number_range_low(prenum)
	if not prenum then return end
	local count = 0
	local value = nil
	for out in string.gmatch(prenum, "[^-]+") do
		if parse.number(out) == nil then
			return nil
		end
		count = count + 1
		if count == 1 then
			value = out
		end
		if count > 2 then
			return nil
		end
	end
	return parse.number(value)
end

function parse.number_or_number_range_high(prenum)
	if not prenum then return end
	local count = 0
	local value = nil
	for out in string.gmatch(prenum, "[^-]+") do
		if parse.number(out) == nil then
			return nil
		end
		count = count + 1
		if count == 2 then
			value = out
		end
		if count > 2 then
			return nil
		end
	end
	return parse.number(value)
end

-- Yes/No
local yes_no = {
	['Yes'] = 'true',
	['No'] = 'false',
	['N/A'] = 'NIL',
}
function parse.yes_no(text)
	if yes_no[text] ~= nil then
		return text
	end
	return nil
end
function parse.yes_no_smw(text)
	if text == 'N/A' then
		return nil
	end
	local bool = yes_no[text]
	if bool ~= nil then
		return bool
	end
	return nil
end

-- Premade Params --
--------------------

-- Standardized actions function
parse.actions = {
	name = 'actions',
	func = parse.has_content,
}

-- Standardized name function
parse.name = {
	name = 'name',
	func = parse.has_content,
	smw_property = 'Name',
	category_incomplete = 'Needs name',
}
local rarities = {"Common", "Uncommon", "Rare", "Epic"}
function parse.get_rarity_func(name)
    for _, rarity in ipairs(rarities) do
        if name:sub(1, #rarity) == rarity then
            return rarity
        end
    end
    return nil
end
parse.rarity_from_name = {
	name = 'rarity_from_name',
	func = {name = parse.get_rarity_func, params = {Infobox.raw_param('name')}}
}

-- Standardized description function
parse.description = {
	name = 'description',
	func = parse.has_content,
	smw_property = 'Description',
	category_incomplete = 'Needs description',
}

-- Standardized image function
function parse.image_name(img)
	if img then
		return string.match(img, '%[%[(File:.+%.%w%w%w)|?%d*x?%d*p?x?%]%]')
	end
	return nil
end
function parse.image_height(img, default)
	if img then
		return string.match(img, '%[%[File:.+%.%w%w%w|%d*x(%d*)px%]%]') or default
	end
	return default
end
function parse.image_width(img, default)
	if img then
		return string.match(img, '%[%[File:.+%.%w%w%w|(%d*)x?%d*px%]%]') or default
	end
	return default
end
function parse.image_func(img, default_width, default_height)
	local name = parse.image_name(img)
	local width = parse.image_width(img, default_width)
	local height = parse.image_height(img, default_height)
	local size = ''
	if width and height then
		size = '|'..width..'x'..height..'px'
	elseif width then
		size = '|'..width..'px'
	elseif height then
		size = '|x'..height..'px'
	end
	if name then
		return '[['..name..size..']]'
	end
	return nil
end
function parse.image_smw(img)
	return parse.image_name(img)
end

parse.image = {
	name = 'image',
	func = parse.image_func,
	smw_property = 'Image',
	smw_func = parse.image_smw,
	empty = '[[Special:Upload|Please upload an image!]]',
	category_incomplete = 'Needs image',
}
parse.image_size300 = {
	name = 'image',
	func = {name = parse.image_func, params = {Infobox.raw_param('image'), 300, 300}},
	smw_property = 'Image',
	smw_func = parse.image_smw,
	empty = '[[Special:Upload|Please upload an image!]]',
	category_incomplete = 'Needs image',
}


-- Episode
local valid_episodes = {
	['none'] = 'None',
	['hopeport'] = 'Hopeport',
	['hopeforest'] = 'Hopeforest',
	['mine of mantuban'] = 'Mine of Mantuban',
	['crenopolis'] = 'Crenopolis',
	['stonemaw hill'] = 'Stonemaw Hill',
	['bleakholm crags'] = 'Bleakholm Crags'
}
function parse.episode_func(episode)
	local valid_episode = valid_episodes[string.lower(episode or '')]
	if valid_episode then
		if valid_episode == 'None' then
			return '[[File:Unknown episode icon.png|18px|link=]] None'
		else
			return '[[File:'..valid_episode..' episode icon.png|18px|link='..valid_episode..']] [['..valid_episode..']]'
		end
	end
	return nil
end
function parse.episode_smw(episode)
	local valid_episode = valid_episodes[string.lower(episode or '')]
	if valid_episode then
		return valid_episode
	end
	return nil
end
parse.episode = {
	name = 'episode',
	func = parse.episode_func,
	smw_property = 'Episode',
	smw_func = parse.episode_smw,
	category_incomplete = 'Needs episode',
}
parse.additional_episode = {
	name = 'additional_episode',
	func = parse.episode_func,
	smw_property = 'Additional Episode',
	smw_func = parse.episode_smw,
	category_complete = 'Infobox with two episodes',
}

-- Premium
local premium_episodes = {
	['none'] = 'No',
	['hopeport'] = 'No',
	['hopeforest'] = 'No',
	['mine of mantuban'] = 'Yes',
	['crenopolis'] = 'Yes',
	['stonemaw hill'] = 'Yes',
	['bleakholm crags'] = 'Yes'
}
function parse.premium_func(episode)
	local premium_episode = premium_episodes[string.lower(episode or '')]
	return premium_episode
end
function parse.premium_smw(episode)
	return parse.yes_no_smw(parse.premium_func(episode))
end
parse.premium = {
	name = 'premium',
	func = {name = parse.premium_func, params = {Infobox.raw_param('episode')}},
	smw_property = 'Premium',
	smw_func = {name = parse.premium_smw, params = {Infobox.raw_param('episode')}}
}

-- Release
local function unix_time(date)
	-- Convert a time to unix time
	if date == nil then
		return nil
	end
	local year, month, day = string.match(date, '(%d+)-(%d+)-(%d+)')
	if year == nil or month == nil or day == nil then
		return nil
	end
	return os.time{year=year, month=month, day=day}
end
function parse.release_func(date)
	local time = unix_time(date)
	if time == nil then
		return nil
	end
	local formatted_date = os.date('[[%d %B]] [[%Y]]', time) -- [[01 January]] [[2024]]
	formatted_date = string.gsub(formatted_date, '%[%[0', '[[') -- Convert [[01 January]] [[2024]] to [[1 January]] [[2024]]
	local iso_date = os.date('%Y-%m-%d', time) -- 2024-01-01
	local update_string = formatted_date .. ' ([[Game updates/' .. iso_date .. '|Update]])'
	return update_string
end
function parse.release_smw(date)
	local time = unix_time(date)
	if time == nil then
		return nil
	end
	local formatted_date = os.date('%Y-%m-%d', time) -- 2024-01-01
	return formatted_date
end
parse.release = {
	name = 'release',
	func = parse.release_func,
	category_incomplete = 'Needs release date',
	smw_property = 'Release Date',
	smw_func = parse.release_smw,
}

-- Value
function parse.value_func(val)
	if val == '' or val == ' ' then
		return
	elseif val == 'N/A' then
		return 'N/A'
	end
	local status, val = pcall(currency, val)
	if status then
		return val
	end
end
parse.value = {
	name = 'value',
	func = parse.value_func,
	category_incomplete = 'Items needing value',
	smw_property = 'Value',
	smw_func = parse.number
}

-- Profession
function parse.profession_bubble_func(profession, level)
	local profession_valid = parse.has_content(profession)
	local profession_valid_link = profession_valid
	local level_valid = parse.number_or_number_range(level)
	local category_error = false
	if not profession_valid and not level_valid then
		return nil
	end
	if not profession_valid and level_valid then
		-- Profession undefined but level defined, invalid, show an unknown profession
		profession_valid = 'Unknown episode'
		profession_valid_link = ''
		category_error = true
	end
	if profession_valid and not level_valid then
		-- Profession defined without level, invalid, show an unknown level
		level_valid = '?'
		category_error = true
	end
	return '[[File:'..profession_valid..' icon.png|x30px|link='..profession_valid_link..']] '..level_valid..(category_error and '[[Category:Invalid profession bubble]]' or '')
end
function parse.profession_bubble_smw(profession, level)
	local profession_valid = parse.has_content(profession)
	local level_valid = parse.number(level)
	if not profession_valid then
		return nil
	end
	if not level_valid then
		return nil
	end
	return profession_valid..','..level_valid
end
parse.profession_bubble_a = {
	name = 'profession_bubble_a',
	func = {name = parse.profession_bubble_func, params = {Infobox.raw_param('profession_a'), Infobox.raw_param('profession_a_level')}},
	smw_property = 'Profession Requirement A',
	smw_func = {name = parse.profession_bubble_smw, params = {Infobox.raw_param('profession_a'), Infobox.raw_param('profession_a_level')}},
}
parse.profession_a_smw = {
	name = 'profession_a',
	func = parse.has_content,
	smw_property = 'Profession A',
}
parse.profession_a_level_smw = {
	name = 'profession_a_level',
	func = parse.number_or_number_range_low,
	smw_property = 'Profession Level A',
}
parse.profession_a_level_high_smw = {
	name = 'profession_a_level_high',
	func = {name = parse.number_or_number_range_high, params = {Infobox.raw_param('profession_a_level')}},
	smw_property = 'Profession Level A High',
}
parse.profession_bubble_b = {
	name = 'profession_bubble_b',
	func = {name = parse.profession_bubble_func, params = {Infobox.raw_param('profession_b'), Infobox.raw_param('profession_b_level')}},
	smw_property = 'Profession Requirement B',
	smw_func = {name = parse.profession_bubble_smw, params = {Infobox.raw_param('profession_b'), Infobox.raw_param('profession_b_level')}},
}
parse.profession_b_smw = {
	name = 'profession_b',
	func = parse.has_content,
	smw_property = 'Profession B',
}
parse.profession_b_level_smw = {
	name = 'profession_b_level',
	func = parse.number_or_number_range_low,
	smw_property = 'Profession Level B',
}
parse.profession_b_level_high_smw = {
	name = 'profession_b_level_high',
	func = {name = parse.number_or_number_range_high, params = {Infobox.raw_param('profession_b_level')}},
	smw_property = 'Profession Level B High',
}

-- Variant categories
local function strip_link(text)
	if text ~= nil then
		if text:sub(1, 2) == '[[' and text:sub(-2) == ']]' and not text:find('|') then
    		text = text:sub(3, -3)  -- Remove the [[]]
		end
	end
	return text
end
local variant_category_smw_cache = {}
local function variant_category_smw_lookup(v)
	v = strip_link(v)
	if not variant_category_smw_cache[v] then
		local smw_data = mw.smw.ask{
			'[[Category:Variant categories]][[' .. v .. ']]',
			'?Name',
			'?Name color'
		}
		if not smw_data then
			variant_category_smw_cache[v] = { name = v, color = nil }
		else
			local color = smw_data[1]['Name color']
			if color then
				color = mw.text.trim(color)
			end
			variant_category_smw_cache[v] = { name = smw_data[1].Name, color = color }
			mw.logObject(variant_category_smw_cache)
		end
	end
	return variant_category_smw_cache[v]
end
function parse.variant_category_func(v)
	v = parse.has_content(v)
	if v == nil then
		return nil
	elseif v == 'N/A' then
		return 'N/A'
	end
	v = strip_link(v)
	local name = variant_category_smw_lookup(v).name
	if name == v then
		return '[['..v..']]'
	end
	return ('[[%s|%s]]'):format(v, name)
end
function parse.variant_smw_func(v)
	v = parse.has_content(v)
	if v == 'N/A' then
		return 
	end
	return v
end
local function name_without_variant_category(name, variant_name)
	variant_name = parse.variant_smw_func(variant_name)
	if variant_name and name:sub(-1-#variant_name) == ' '..variant_name then
		-- Ends with the variant name. Remove it
		name = name:sub(1, -2-#variant_name)
	end
	return name
end
local function name_with_variant_category(name, v, passive, is_for_smw)
	v = parse.variant_smw_func(v)
	if v == nil then
		return name
	end
	v = strip_link(v)
	passive = parse.yes_no_smw(passive) == 'true'
	local variant_cat_data = variant_category_smw_lookup(v)
	name = name_without_variant_category(name, variant_cat_data.name)
	if is_for_smw then
		return ('%s %s'):format(name, variant_cat_data.name)
	end
	local result = mw.html.create('span')
		:addClass('infobox-varianted-name')
		:tag('span')
			:addClass('infobox-varianted-name-variant')
			:wikitext(name)
		:done()
	result:tag('br')
	if passive then
		result:wikitext('[[File:Passive small icon.png|14px|link=Passive activity]] ')
	end
	result:tag('span')
		:addClass('infobox-varianted-name-category')
		:css{ color = variant_cat_data.color }
		:wikitext(variant_cat_data.name)
	return tostring(result)
end
function parse.name_with_variant_category_func(name, v, passive, name_override)
	return name_override or name_with_variant_category(name, v, passive, false)
end
function parse.name_with_variant_category_smw_func(name, v, passive, name_override)
	return name_override or name_with_variant_category(name, v, passive, true)
end
function parse.name_without_variant_category_func(name, v)
	if not (name and v) then
		return name
	end
	v = strip_link(v)
	return name_without_variant_category(name, variant_category_smw_lookup(v).name)
end

parse.variant = {
	name = 'variant',
	func = parse.variant_category_func,
	smw_func = parse.variant_smw_func,
	smw_property = 'Variant of',
	category_incomplete = 'Needs variant'
}

parse.name_with_variant_category = {
	name = 'name',
	func = {name=parse.name_with_variant_category_func, params = {Infobox.raw_param('name'), Infobox.raw_param('variant'), Infobox.raw_param('passive'), Infobox.raw_param('name_override')}},
	smw_func = {name=parse.name_with_variant_category_smw_func, params = {Infobox.raw_param('name'), Infobox.raw_param('variant'), Infobox.raw_param('passive'), Infobox.raw_param('name_override')}},
	smw_property = 'Name',
	category_incomplete = 'Needs name'
}

parse.variant_name = {
	name = 'variant_name',
	func = {name=parse.name_without_variant_category_func, params = {Infobox.raw_param('name'), Infobox.raw_param('variant')}},
	smw_property = 'Variant name'
}

-- Variant type
parse.variant_type = {
	name = 'variant_type',
	func = {name=parse.variant_type_func, params = {Infobox.raw_param('variant_type')}},
	smw_func = parse.has_content,
	smw_property = 'Variant type',
	category_incomplete = 'Needs variant type'
}

local valid_variant_types = {
	['item'] = 'Item',
	['monster'] = 'Monster',
	['skill node'] = 'Skill node'
}
function parse.variant_type_func(type)
	local valid_type = valid_variant_types[string.lower(type or '')]
	if valid_type then
		return valid_type..'[[Category:'..valid_type..' variant]]'
	else
		return '[[Category:Invalid variant type]]'
	end
	return nil
end

parse.passive = {
	name = 'passive',
	func = parse.yes_no,
	smw_property = 'Passive',
	smw_func = parse.yes_no_smw,
	category_incomplete = 'Needs passiveness'
}

function parse.duration_func(hours)
	hours = string.gsub(hours or '',',','')
	return (tonumber(hours) .. " Hours")
end

parse.duration = {
	name = 'duration',
	func = parse.duration_func,
	smw_property = 'Duration',
	category_incomplete = 'Needs duration',
}

parse.aggressive = {
	name = 'aggressive',
	func = parse.yes_no,
	smw_property = 'Aggressive',
	smw_func = parse.yes_no_smw,
	category_incomplete = 'Needs aggressiveness'
}

function parse.difficulty_func(val)
	if val == "0" then
		return "☆☆☆☆☆"	
	end
	if val == "1" then
		return "★☆☆☆☆"
	end
	if val == "2" then
		return "★★☆☆☆"
	end
	if val == "3" then
		return "★★★☆☆"
	end
	if val == "4" then
		return "★★★★☆"
	end
	if val == "5" then
		return "★★★★★"
	end
	return "N/A"
end
function parse.difficulty_smw(val)
	if val == 'N/A' then
		return -1
	end
	val = tonumber(val) -- Intentionally do not use parse.tonumber here
	if val == nil then
		return nil
	end
	if val >= 0 and val <= 5 and math.floor(val) == val then
		return val
	end
	return nil
end

-- Quest difficulty
parse.difficulty = {
	name = 'difficulty',
	func = parse.difficulty_func,
	smw_property = 'Difficulty',
	smw_func = parse.difficulty_smw,
	category_incomplete = 'Needs difficulty'
}

local valid_quest_types = {
	['main'] = 'Main',
	['side'] = 'Side'
}
function parse.quest_type_func(type)
	local valid_type = valid_quest_types[string.lower(type or '')]
	if valid_type then
		return valid_type
	else
		return 'None'
	end
	return nil
end
function parse.quest_type_smw(type)
	local valid_type = valid_quest_types[string.lower(type or '')]
	if valid_type then
		return valid_type
	end
	return nil
end

-- Quest type
parse.quest_type = {
	name = 'quest_type',
	func = parse.quest_type_func,
	smw_property = 'quest_type',
	smw_func = parse.quest_type_smw,
	category_incomplete = 'Needs quest_type'
}

-- Quest
function parse.quest_smw(quest)
	if quest == 'No' then
		return nil
	end
	return parse.has_content(quest)
end

parse.quest = {
	name = 'quest',
	func = parse.has_content,
	smw_property = 'Quest',
	smw_func = parse.quest_smw,
	category_incomplete = 'Needs quest'
}

-- Unlock Level
function parse.unlock_profession_func(unlock_profession, profession, level)
	if level == 'N/A' then
		return parse.has_content(unlock_profession or 'N/A')
	end
	return parse.has_content(unlock_profession or profession)
end

function parse.unlock_profession_func_smw(unlock_profession, profession, level)
	local prof = parse.unlock_profession_func(unlock_profession, profession, level)
	if prof == 'N/A' then
		return nil
	end
	return prof
end

function parse.unlock_level_func(unlock_profession, profession, level)
	if parse.has_content(level) == 'N/A' then
		-- unlock_profession set but level = N/A is not handled, handle it here
		-- (and in the smw func) if needed for whatever reason
		return 'N/A'
	end

	local level_valid = parse.number(level)
	local profession_valid = parse.unlock_profession_func(unlock_profession, profession, level)
	local profession_valid_link = profession_valid

	if not profession_valid and not level_valid then
		return nil
	end

	if not profession_valid and level_valid then
		-- Profession undefined but level defined, invalid, show an unknown profession
		profession_valid = 'Unknown episode'
		profession_valid_link = ''
	end

	if profession_valid and not level_valid then
		-- Profession defined without level, invalid, show an unknown level
		level_valid = '?'
	end

	return '[[File:'..profession_valid..'_icon.png|link='..profession_valid_link..'|width=18x18]] '..level_valid
end

function parse.unlock_level_smw(unlock_profession, profession, level)
	if parse.has_content(level) == 'N/A' then
		return nil
	end
	local profession_valid = parse.unlock_profession_func(unlock_profession, profession)
	local level_valid = parse.number(level)

	if not profession_valid then
		return nil
	end

	if not level_valid then
		return nil
	end
	
	return level_valid
end

parse.unlock_profession = {
	name = 'unlock_profession',
	func = {name = parse.unlock_profession_func, params = {Infobox.raw_param('unlock_profession'), Infobox.raw_param('profession_a'), Infobox.raw_param('unlock_level')}},
	smw_property = 'Unlock profession',
	smw_func = {name = parse.unlock_profession_func_smw, params = {Infobox.raw_param('unlock_profession'), Infobox.raw_param('profession_a'), Infobox.raw_param('unlock_level')}},
}

parse.unlock_level = {
	name = 'unlock_level',
	func = {name = parse.unlock_level_func, params = {Infobox.raw_param('unlock_profession'), Infobox.raw_param('profession_a'), Infobox.raw_param('unlock_level')}},
	smw_property = 'Unlock level',
	smw_func = {name = parse.unlock_level_smw, params = {Infobox.raw_param('unlock_profession'), Infobox.raw_param('profession_a'), Infobox.raw_param('unlock_level')}},
	category_incomplete = 'Needs unlock level',
}

-- Knowledge
parse.knowledge = {
	name = 'knowledge',
	func = parse.number,
	smw_property = 'Knowledge',
	category_incomplete = 'Needs knowledge',
}

-- Passive Monster required Weapon Strength
parse.weapon_strength = {
	name = 'weapon_strength',
	func = parse.number,
	smw_property = 'Weapon strength',
	category_incomplete = 'Needs weapon strength',
}

parse.health = {
	name = 'health',
	func = parse.number,
	smw_property = 'Health',
	category_incomplete = 'Needs health',
}

parse.experience = {
	name = 'experience',
	func = parse.number,
	smw_property = 'Experience',
	category_incomplete = 'Needs experience',
}

local valid_attack_styles = {
    ['none'] = 'None',
    ['impact'] = 'Impact',
    ['cryonae'] = 'Cryonae',
    ['arborae'] = 'Arborae',
    ['tempestae'] = 'Tempestae',
    ['infernae'] = 'Infernae',
    ['necromae'] = 'Necromae',
}

local function attack_style_func(style)
    local attack_style = valid_attack_styles[string.lower(style or '')]
    if attack_style then
        if attack_style == 'None' then
            return 'None'
        else
            return string.format('[[File:%s damage icon.png|18px|link=%s]] [[%s]]', attack_style, attack_style, attack_style)
        end
    end
    return nil
end

local function attack_style_smw(style)
	local attack_style = valid_attack_styles[string.lower(style or '')]
	if attack_style then
		return attack_style
	else
		return nil
	end
end

parse.attack_style = {
	name = 'attack_style',
	func = attack_style_func,
	smw_property = 'Attack style',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs attack style',
}

parse.immune_to = {
	name = 'immune_to',
	func = attack_style_func,
	smw_property = 'Immune to',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs immune to',
}

parse.vulnerable_to = {
	name = 'vulnerable_to',
	func = attack_style_func,
	smw_property = 'Vulnerable to',
	smw_func = attack_style_smw,
	category_incomplete = 'Needs vulnerable to',
}

-- Bank
parse.bank = {
	name = 'bank',
	func = parse.has_content,
	smw_property = 'Bank',
	category_complete = 'Bankable items'
}

-- Transmog Event
parse.event = {
	name = 'event',
	func = parse.has_content,
	smw_property = 'Event',
}

-- Transmog Equipment Slot
parse.slot = {
	name = 'slot',
	func = parse.has_content,
	smw_property = 'Slot',
}

return parse
-- </nowiki>