Editing Module:ItemDataGive feedback

local p = {};
local lang = require "Module:Lang"
local util_module = require "Module:Utilities"
local data = mw.loadJsonData("Data:ItemData.json")

-- A list of item properties that should have a '%' sign appended to their base value.
local percentage_properties = {
    AbilityLifestealPercentHero = true,
    BaseAttackDamagePercent = true,
    BonusAbilityDurationPercent = true,
    BonusBulletSpeedPercent = true,
    BonusClipSizePercent = true,
    BonusFireRate = true,
    BonusMeleeDamagePercent = true,
    BulletArmorReduction = true,
    BulletLifestealPercent = true,
    BulletResist = true,
    CooldownReduction = true,
    CooldownReductionPctOnOthers = true,
    CritDamagePercent = true,
    DamagePctVsNonHeroes = true,
    DeathImmunityDamageReduction = true,
    DeflectionPercent = true,
    DotHealthPercent = true,
    FireRateSlow = true,
    GroundDashReductionPercent = true,
    HealAmpCastPercent = true,
    HealAmpReceivePenaltyPercent = true,
    HealAmpRegenPenaltyPercent = true,
    HealAmpRegenPercent = true,
    HealLifePercentOutOfCombat = true,
    HealPercentAmount = true,
    HealPercentPerHeadshot = true,
    ItemCooldownReduction = true,
    MagicIncreasePerStack = true,
    MagicResistReduction = true,
    MaxSlowPercent = true,
    MaxHealthLossPercent = true,
    MeleeDistanceScale = true,
    MeleeResistPercent = true,
    MoveWhileShootingSpeedPenaltyReductionPercent = true,
    MoveWhileZoomedSpeedPenaltyReductionPercent = true,
    NonHeroHealPct = true,
    NonPlayerBonusWeaponPower = true,
    NonPlayerBulletResist = true,
    OutgoingDamagePenaltyPercent = true,
    PercentDamage = true,
    ProcChance = true,
    RicochetDamagePercent = true,
    SlideScale = true,
    SlowPercent = true,
    SlowResistancePercent = true,
    StatusResistancePercent = true,
    TechArmorDamageReduction = true,
    TechPowerPercent = true,
    TechPowerReduction = true,
    TechRadiusMultiplier = true,
    TechRangeMultiplier = true,
    TechResist = true,
    TechResistBelowThreshold = true
}

---------------------------------------- Utility functions

-- Returns the table of a specific item
-- @function   get_json_item
-- @param      {string}
-- @return     {table}
local function get_json_item(name)   
	for _, v in pairs(data) do
		if (v["Name"] == name) then
			return v
		end
	end
	return nil
end

-- Returns an array of item tables that have the same properties
-- @function   get_similar_items
-- @param      {string}
-- @return     {array of tables}
local function get_similar_items(property)
	local similarItems = {}
	for _, v in pairs(data) do
		if (v[property] ~= nil) then
			table.insert(similarItems, v)
		end
	end
	return similarItems
end

-- Adds commas delimiter to the thousands place
local function Format(amount)
	local contentLanguage = mw.language.getContentLanguage()
    local formatted = amount
    if(type(formatted) ~= "number") then return "<span style=\"color:red;\">Cannot format non-number value.</span>" end
    return contentLanguage:formatNum(tonumber(formatted))
end

--- Get cost of an item 
-- @function   get_cost
-- @param      {string}
-- @return     {number}
local function get_cost(item_name)
	local item = get_json_item(item_name)
	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
	return tonumber(item["Cost"])
end

--- Get type/slot/category of an item 
-- @function   get_type
-- @param      {string} item_name
-- @param      {boolean} raw (optional)
-- @return     {string}
local function get_type(item_name, raw)
	local item = get_json_item(item_name)
	if not item then 
		return "<span style=\"color:red;\">Item Not Found.</span>"
	end

	local slot = item["Slot"]
	if not slot then return nil end

	local key_map = {
		Weapon = 'CitadelCategoryWeapon',
		Armor = 'CitadelCategoryArmor',
		Tech = 'CitadelCategoryTech'
	}

	local key = key_map[slot]
	if not key then return nil end

	if raw then
		return lang.get_string(key, "en")
	else
		return lang.get_string(key)
	end
end


---------------------------------------- Invocable functions

--- {{#invoke:ItemData|get_cost|ITEM_NAME}} access point
p.get_cost = function(frame)
	local item_name = frame.args[1]
	return Format(get_cost(item_name))
end

-- Module access point
function p._get_cost(a)
	a = tostring(a) or '0'
	return get_cost(a)
end

-- {{#invoke:ItemData|get_type|ITEM_NAME}} access point
p.get_type = function(frame)
	local item_name = frame.args[1]
	-- Accept 'raw' as string "true" (case sensitive)
	local raw = frame.args['raw'] == 'true'
	return get_type(item_name, raw)
end

-- Module access point
function p._get_type(a)
	a = tostring(a) or ""
	return get_type(a)
end

--{{#invoke:ItemData|is_active|ITEM_NAME}}--
p.is_active = function(frame)
	local item_name = frame.args[1]
	local item = get_json_item(item_name)
	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
	
	if (item["Activation"] == "Passive") then
		return	false
	else 
		return true
	end
end

--{{#invoke:ItemData|get_prop|ITEM_NAME|PROPERTY}}--
--check Data:ItemData.json for properties
p.get_prop = function(frame)
	local item_name = frame.args[1]
	local property = frame.args[2]
	local item = get_json_item(item_name)
	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end

	local prop_value = item[property]
	if (prop_value == nil) then return nil end

	local display_value
	local scaling_str = "" -- Default to an empty string for non-scaled values

	-- Determine the base value and scaling string (if any)
	if(type(prop_value) == "table") then
		if prop_value["Value"] ~= nil and prop_value["Scale"] ~= nil and prop_value["Scale"]["Value"] ~= nil and prop_value["Scale"]["Type"] ~= nil then
			-- This is a structured attribute with scaling data
			display_value = tostring(prop_value["Value"])
			local scale_val = tonumber(prop_value["Scale"]["Value"])
			
			if scale_val ~= 0 then
				local scale_type = prop_value["Scale"]["Type"]
				local rounded_scale_val = util_module.round_to_sig_fig(scale_val, 2)
				
				local template_title
				if scale_type == "power_increase" then
					template_title = "Template:Boon"
				else
					template_title = "Template:Ss"
				end
				
				local template_args = { [1] = rounded_scale_val }
				-- Add a space before the scaling template for proper separation
				scaling_str = " " .. mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
			end
		else
			-- This is a simple list (e.g., TargetTypes), handle and return it directly
			local tableValues = {}
			for _, v in pairs(prop_value) do
				table.insert(tableValues, tostring(v))
			end
			return table.concat(tableValues, ", ")
		end
	else
		-- This is a simple, non-table property
		display_value = tostring(prop_value)
	end
	
	-- Assemble the final string, adding the '%' sign if necessary
	if percentage_properties[property] == true then
		return display_value .. "%" .. scaling_str
	else
		return display_value .. scaling_str
	end
end

p.get_component_name = function(frame)
	local item_name = frame.args[1]
	local item = get_json_item(item_name)
	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
	
	local components = item['Components']
	--return empty string if no component found
	if(components == nil) then return nil end
	
	local component_key = components[1]
	local component = data[component_key]
	if (component == nil) then return nil end
	
	return component['Name']
end

-- {{Items count}} access point
function p.get_headcount()
	local iter = 0
	local tbl = get_similar_items("IsDisabled")
	for _, v in ipairs(tbl) do
		if (v["IsDisabled"] == false and v["Name"] ~= nil) then
			iter = iter + 1	
		end
	end
	return iter
end

--get codename of the item--
p.get_codename = function(frame)
	local name = frame.args[1]
 -- Exception for "Extended Magazine"
    if name == "Extended Magazine" then
        return "upgrade_clip_size"
    end

	for k, v in pairs(data) do
		if v["Name"] == name then
			return k  -- returning the key (i.e., name of the table entry)
		end
	end
	return nil  -- return nil if not found
end

return p