Module:GameSkills

Module:GameSkills

Module:GameSkills renders skill data from Data:skills.json into a reusable infobox-style table.

It is intended to be used via a template (for example Template:Skill) so that skills can be embedded on any page without creating individual skill pages.

This module:

• Loads data via Module:GameData → GameData.loadSkills().
• Looks up skills primarily by display "Name" (what editors use), with "Internal Name" as a fallback.
• Builds a table with only the fields that actually exist for that skill.

---

Data source

Skill data comes from Data:skills.json, which is a JSON page with this top-level structure (see Module:GameData/doc for full details):

{
  "version": "SpiritVale-0.8.2",
  "schema_version": 1,
  "generated_at": "2025-12-12T17:24:05.807675+00:00",
  "records": [
    {
      "Name": "Some Skill",
      "Internal Name": "SomeSkillInternalId",
      "...": "other fields specific to skills"
    }
  ]
}

Each record is a single skill. Important keys:

• "Name" – the display name (what players and editors will usually see and use).
• "Internal Name" – the stable ID used internally and available as an optional parameter for power users and tooling.

---

Output

For a given skill, the module renders a table with the CSS class spiritvale-skill-infobox.

Depending on what exists in the JSON record, the table may include:

• Header row with skill name (and icon, if present).
• Icon (from "Icon", as a file name like skill-example.webp).
• Description.
• Type information:
  • Damage Type
  • Element Type
  • Target Type
  • Cast Type
• Max Level.
• Users:
  • Classes
  • Summons
  • Monsters
  • Events
• Requirements:
  • Required Skills (with required level)
  • Required Weapons
  • Required Stances
• Mechanics:
  • Range
  • Cast Time / Cooldown / Duration
  • Mana Cost
• Damage and scaling:
  • Main Damage (base and per-level, where present)
  • Scaling (stat-based contributions)
• Status interactions:
  • Status Applications (status name, scope, basic duration/chance info)

Rows are only shown if the underlying field exists in the JSON for that skill.

---

Public interface

The module exposes a single entry point for templates:

GameSkills.infobox(frame)

This is usually called via #invoke from a template, not directly from pages.

It accepts the following parameters (either passed directly or via a wrapper template):

• 1 – unnamed parameter; treated as the skill "Name".
• name – explicit display "Name" of the skill (equivalent to 1).
• id – "Internal Name" of the skill (optional fallback / power use).

Lookup order:

1. If name or the first unnamed parameter is provided and matches a record’s "Name", that record is used.
2. Otherwise, if id is provided and matches an "Internal Name", that record is used.
3. If nothing is found, a small error message is returned and the page is categorized for tracking.

Example direct usage (not recommended; normally use a template):

No skills found for: GameSkills

or:

No skills found for: GameSkills

---

Template:Skill

The recommended way to use this module is via a small wrapper template, for example:

Template:Skill

 No skills found for: GameSkills

Typical usage on any page:

Bash	Delivers a crushing blow with a chance to stun the target.
General
Max Level	10
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Requirements
Required Skills	Axe Mastery (Lv.1)
Type
Damage Type	Melee
Element	Neutral
Target	Enemy
Cast Type	Target
Mechanics
Resource Cost	MP: 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13
Combo	Type: Ready, Duration: 4s
Damage and Scaling
Main Damage	100% + 25 / 50 / 75 / 100 / 125 / 150 / 175 / 200 / 225 / 250 Attack Per Level
Scaling	2% Attack Per Strength
Modifiers
Flags	Special: Self Centered
Status Effects
Applies	Target – Stun (Duration: 3s, Chance: 3% / 6% / 9% / 12% / 15% / 18% / 21% / 24% / 27% / 30%)

or, explicitly:

Bash	Delivers a crushing blow with a chance to stun the target.
General
Max Level	10
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Requirements
Required Skills	Axe Mastery (Lv.1)
Type
Damage Type	Melee
Element	Neutral
Target	Enemy
Cast Type	Target
Mechanics
Resource Cost	MP: 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13
Combo	Type: Ready, Duration: 4s
Damage and Scaling
Main Damage	100% + 25 / 50 / 75 / 100 / 125 / 150 / 175 / 200 / 225 / 250 Attack Per Level
Scaling	2% Attack Per Strength
Modifiers
Flags	Special: Self Centered
Status Effects
Applies	Target – Stun (Duration: 3s, Chance: 3% / 6% / 9% / 12% / 15% / 18% / 21% / 24% / 27% / 30%)

Internal IDs can still be used when needed:

Unknown Skill: Bash_InternalId

This keeps page wikitext simple while centralizing all JSON loading and formatting logic inside Lua.

---

-- Module:GameSkills
--
-- Renders active skill data (from Data:skills.json) into an infobox-style table
-- and can also list all skills for a given user/class.
--
-- Usage (single skill):
--   {{Skill|Heal}}
--   {{Skill|name=Heal}}
--   {{Skill|id=Heal_InternalId}}
--
-- Usage (auto-list on class page, e.g. "Acolyte"):
--   {{Skill}}                  -> lists all Acolyte skills (page name)
--   {{Skill|Acolyte}}          -> same, if no skill literally called "Acolyte"

local GameData = require("Module:GameData")

local p = {}

----------------------------------------------------------------------
-- Internal helpers
----------------------------------------------------------------------

local skillsCache

local function getSkills()
	if not skillsCache then
		skillsCache = GameData.loadSkills()
	end
	return skillsCache
end

local function getArgs(frame)
	local parent = frame:getParent()
	if parent then
		return parent.args
	end
	return frame.args
end

local function listToText(list, sep)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end
	return table.concat(list, sep or ", ")
end

local function addRow(tbl, label, value)
	if value == nil or value == "" then
		return
	end
	local row = tbl:tag("tr")
	row:tag("th"):wikitext(label):done()
	row:tag("td"):wikitext(value):done()
end

local function addSectionHeader(tbl, label)
	local row = tbl:tag("tr")
	local cell = row:tag("th")
	cell:attr("colspan", 2)
	cell:addClass("spiritvale-infobox-section-header")
	cell:wikitext(label)
end

local function trim(s)
	if type(s) ~= "string" then return nil end
	s = mw.text.trim(s)
	if s == "" then return nil end
	return s
end

local function toNum(v)
	if type(v) == "number" then return v end
	if type(v) == "string" then return tonumber(v) end
	return nil
end

local function fmtNum(n)
	if type(n) ~= "number" then
		return (n ~= nil) and tostring(n) or nil
	end
	if math.abs(n - math.floor(n)) < 1e-9 then
		return tostring(math.floor(n))
	end
	local s = string.format("%.4f", n)
	s = mw.ustring.gsub(s, "0+$", "")
	s = mw.ustring.gsub(s, "%.$", "")
	return s
end

-- Handles either a scalar OR {Value=..., Unit=...}
-- IMPORTANT: do NOT convert percent_decimal/percent_whole; just format around stored values.
local function formatUnitValue(v)
	if type(v) == "table" and v.Value ~= nil then
		local unit = v.Unit
		local val = v.Value

		if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
			return tostring(val) .. "%"
		elseif unit == "seconds" then
			return tostring(val) .. "s"
		elseif unit == "meters" then
			return tostring(val) .. "m"
		elseif unit == "tiles" then
			return tostring(val) .. " tiles"
		elseif unit and unit ~= "" then
			return tostring(val) .. " " .. tostring(unit)
		else
			return tostring(val)
		end
	end

	if v == nil then
		return nil
	end
	return tostring(v)
end

----------------------------------------------------------------------
-- Lookups
----------------------------------------------------------------------

-- Lookup by Internal Name
local function getSkillById(id)
	id = trim(id)
	if not id then return nil end
	local dataset = getSkills()
	local byId = dataset.byId or {}
	return byId[id]
end

-- Lookup by display/external Name (for editors)
local function findSkillByName(name)
	name = trim(name)
	if not name then return nil end
	local dataset = getSkills()

	-- Fast path if GameData built byName
	local byName = dataset.byName or {}
	if byName[name] then
		return byName[name]
	end

	-- Fallback scan (older GameData)
	for _, rec in ipairs(dataset.records or {}) do
		if type(rec) == "table" then
			if rec["External Name"] == name or rec["Name"] == name or rec["Display Name"] == name then
				return rec
			end
		end
	end
	return nil
end

----------------------------------------------------------------------
-- Formatting helpers
----------------------------------------------------------------------

local function isFlatList(list)
	if type(list) ~= "table" or #list == 0 then
		return false
	end
	local first = tostring(list[1])
	for i = 2, #list do
		if tostring(list[i]) ~= first then
			return false
		end
	end
	return true
end

local function isNonZeroScalar(v)
	if v == nil then return false end
	if type(v) == "number" then return v ~= 0 end
	if type(v) == "string" then
		local n = tonumber(v)
		if n == nil then
			return v ~= ""
		end
		return n ~= 0
	end
	if type(v) == "table" and v.Value ~= nil then
		return isNonZeroScalar(v.Value)
	end
	return true
end

-- Turns a {Base, Per Level} block into lines:
--   - If Per Level is a list: "Name: v1 / v2 / v3 ..."
--   - If Per Level scalar and non-zero: add "Name Per Level: X"
local function valuePairLines(name, block)
	if type(block) ~= "table" then
		return {}
	end

	local base = block.Base
	local per  = block["Per Level"]

	-- Per Level list (wikiprep expansion)
	if type(per) == "table" then
		if #per == 0 then
			local baseText = formatUnitValue(base)
			if baseText then
				return { string.format("%s: %s", name, baseText) }
			end
			return {}
		end

		-- If it's a flat list, treat as "no scaling" (show single value)
		if isFlatList(per) then
			local baseText = formatUnitValue(base)
			local one = tostring(per[1])
			local show = baseText or one
			if show then
				return { string.format("%s: %s", name, show) }
			end
			return {}
		end

		local vals = {}
		for _, v in ipairs(per) do
			table.insert(vals, formatUnitValue(v) or tostring(v))
		end
		if #vals == 0 then
			return {}
		end
		return { string.format("%s: %s", name, table.concat(vals, " / ")) }
	end

	-- Scalar Per Level
	local lines = {}
	local baseText = formatUnitValue(base)
	local perText  = formatUnitValue(per)

	if baseText then
		table.insert(lines, string.format("%s: %s", name, baseText))
	end
	if perText and isNonZeroScalar(per) then
		table.insert(lines, string.format("%s Per Level: %s", name, perText))
	end

	return lines
end

local function valuePairText(name, block, sep)
	local lines = valuePairLines(name, block)
	if #lines == 0 then
		return nil
	end
	return table.concat(lines, sep or "<br />")
end

local function valuePairRawText(block)
	if type(block) ~= "table" then
		return nil
	end

	local base = block.Base
	local per  = block["Per Level"]

	if type(per) == "table" then
		if #per == 0 then
			return formatUnitValue(base)
		end
		if isFlatList(per) then
			return formatUnitValue(base) or tostring(per[1])
		end
		local vals = {}
		for _, v in ipairs(per) do
			table.insert(vals, formatUnitValue(v) or tostring(v))
		end
		return (#vals > 0) and table.concat(vals, " / ") or nil
	end

	local baseText = formatUnitValue(base)
	local perText  = formatUnitValue(per)

	if baseText and perText and isNonZeroScalar(per) then
		return string.format("%s (Per Level: %s)", baseText, perText)
	end
	return baseText or perText
end

local function basisLabel(entry, isHealing)
	if isHealing then
		return "Healing"
	end
	local atk = entry and entry["ATK-Based"]
	local matk = entry and entry["MATK-Based"]
	if atk and matk then
		return "Attack/Magic Attack"
	elseif atk then
		return "Attack"
	elseif matk then
		return "Magic Attack"
	end
	return "Damage"
end

-- Damage formatting:
--   - Avoid "nil%" when Base is missing/0 and only Per Level exists.
--   - For non-healing: "100% + 40 / 80 / 120 ... Attack Per Level"
--   - For healing: "10 / 20 / 30 ... Healing Per Level"
local function formatDamageEntry(entry, maxLevel, isHealing)
	if type(entry) ~= "table" then
		return nil
	end

	local baseRaw = entry["Base %"]
	local perRaw  = entry["Per Level %"]

	local baseN = toNum(baseRaw)
	local perN  = toNum(perRaw)

	local basis = basisLabel(entry, isHealing)

	-- Healing: never show "%" or "nil%".
	if isHealing then
		-- Prefer per-level expansion if possible
		if perN ~= nil and perN ~= 0 and maxLevel and maxLevel > 0 then
			local start = (baseN ~= nil) and baseN or 0
			local vals = {}
			for lv = 1, maxLevel do
				table.insert(vals, fmtNum(start + (perN * lv)))
			end
			if #vals > 0 then
				return string.format("%s %s Per Level", table.concat(vals, " / "), basis)
			end
		end

		-- Fallbacks
		if baseN ~= nil and baseN ~= 0 then
			return string.format("%s %s", fmtNum(baseN), basis)
		end
		if perN ~= nil and perN ~= 0 then
			return string.format("%s %s Per Level", fmtNum(perN), basis)
		end
		return nil
	end

	-- Non-healing base display: treat Base 0 as "missing" (so we don't show "0% + ...")
	local basePresent = false
	if baseN ~= nil then
		basePresent = (baseN ~= 0)
	else
		if baseRaw ~= nil then
			local s = tostring(baseRaw)
			basePresent = (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
		end
	end

	local baseText = nil
	if basePresent then
		if baseN ~= nil then
			baseText = fmtNum(baseN) .. "%"
		else
			baseText = tostring(baseRaw) .. "%"
		end
	end

	-- If we have no Per Level scaling (or can't expand), show just Base if present.
	if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
		if baseText then
			return string.format("%s %s", baseText, basis)
		end
		return nil
	end

	-- Expand cumulative list: per * 1..maxLevel
	local vals = {}
	for lv = 1, maxLevel do
		table.insert(vals, fmtNum(perN * lv))
	end
	local listText = (#vals > 0) and table.concat(vals, " / ") or nil
	if not listText then
		return baseText
	end

	-- If Base missing/0: just the list (no "nil% +")
	if not baseText then
		return string.format("%s %s Per Level", listText, basis)
	end

	return string.format("%s + %s %s Per Level", baseText, listText, basis)
end

local function formatDamageList(list, maxLevel, includeTypePrefix, isHealing)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, d in ipairs(list) do
		if type(d) == "table" then
			local txt = formatDamageEntry(d, maxLevel, isHealing)
			if txt then
				if includeTypePrefix and d.Type and d.Type ~= "" then
					table.insert(parts, tostring(d.Type) .. ": " .. txt)
				else
					table.insert(parts, txt)
				end
			end
		end
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

-- Scaling should read like:
--   "2% Attack Per Vitality"
-- For pure healing skills:
--   "1% Healing Per Vitality"
local function formatScaling(list, basisOverride)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end

	local parts = {}
	for _, s in ipairs(list) do
		if type(s) == "table" then
			local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
			local pct  = s.Percent
			local pctN = toNum(pct)

			local basis = basisOverride or basisLabel(s, false)

			if pctN ~= nil and pctN ~= 0 then
				table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
			elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
				table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
			end
		end
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

-- Area: Distance then Size (no Effective)
local function formatArea(area)
	if type(area) ~= "table" then
		return nil
	end
	local parts = {}

	local distLine = valuePairText("Distance", area["Area Distance"], "<br />")
	if distLine then
		table.insert(parts, distLine)
	end

	local size = area["Area Size"]
	if size and size ~= "" then
		table.insert(parts, "Size: " .. tostring(size))
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatTimingBlock(bt)
	if type(bt) ~= "table" then
		return nil
	end
	local parts = {}

	local function add(label, key)
		local block = bt[key]
		if type(block) ~= "table" then
			return
		end
		local lines = valuePairLines(label, block)
		for _, line in ipairs(lines) do
			table.insert(parts, line)
		end
	end

	add("Cast Time", "Cast Time")
	add("Cooldown", "Cooldown")
	add("Duration", "Duration")

	if bt["Effect Cast Time"] ~= nil then
		table.insert(parts, "Effect Cast Time: " .. tostring(bt["Effect Cast Time"]))
	end
	if bt["Damage Delay"] ~= nil then
		table.insert(parts, "Damage Delay: " .. tostring(bt["Damage Delay"]))
	end
	if bt["Effect Remove Delay"] ~= nil then
		table.insert(parts, "Effect Remove Delay: " .. tostring(bt["Effect Remove Delay"]))
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatResourceCost(rc)
	if type(rc) ~= "table" then
		return nil
	end
	local parts = {}

	local manaLines = valuePairLines("MP", rc["Mana Cost"])
	for _, line in ipairs(manaLines) do
		table.insert(parts, line)
	end

	local hpLines = valuePairLines("HP", rc["Health Cost"])
	for _, line in ipairs(hpLines) do
		table.insert(parts, line)
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatCombo(combo)
	if type(combo) ~= "table" then
		return nil
	end
	local parts = {}

	if combo.Type then
		table.insert(parts, "Type: " .. tostring(combo.Type))
	end

	local durText = formatUnitValue(combo.Duration)
	if durText then
		table.insert(parts, "Duration: " .. durText)
	end

	if combo.Percent ~= nil then
		local pctText = formatUnitValue(combo.Percent)
		if pctText then
			table.insert(parts, "Bonus: " .. pctText)
		end
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, ", ")
end

-- Special Mechanics:
-- If effect block has Type, render like:
--   "Holy Light - Skill Area + 3"
local function formatMechanicEffects(effects)
	if type(effects) ~= "table" then
		return nil
	end

	local keys = {}
	for k, _ in pairs(effects) do
		table.insert(keys, k)
	end
	table.sort(keys)

	local parts = {}
	for _, name in ipairs(keys) do
		local block = effects[name]
		if type(block) == "table" then
			local t = block.Type
			if t ~= nil and tostring(t) ~= "" then
				local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
				local amt = valuePairRawText(pair)
				if amt then
					table.insert(parts, string.format("%s - %s + %s", tostring(t), tostring(name), amt))
				else
					table.insert(parts, string.format("%s - %s", tostring(t), tostring(name)))
				end
			else
				local txt = valuePairText(name, block, ", ")
				if txt then
					table.insert(parts, txt)
				end
			end
		end
	end

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatModifiers(mods)
	if type(mods) ~= "table" then
		return nil
	end
	local parts = {}

	local function collect(label, sub)
		if type(sub) ~= "table" then
			return
		end
		local flags = {}
		for k, v in pairs(sub) do
			if v then
				table.insert(flags, k)
			end
		end
		table.sort(flags)
		if #flags > 0 then
			table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
		end
	end

	collect("Movement", mods["Movement Modifiers"])
	collect("Combat",   mods["Combat Modifiers"])
	collect("Special",  mods["Special Modifiers"])

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatStatusApplications(list)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end
	local parts = {}
	for _, s in ipairs(list) do
		if type(s) == "table" then
			local scope = s.Scope or "Target"
			local name  = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"

			local seg = scope .. " – " .. tostring(name)
			local detail = {}

			if type(s.Duration) == "table" then
				local t = valuePairText("Duration", s.Duration, "; ")
				if t then table.insert(detail, t) end
			end

			if type(s.Chance) == "table" then
				local t = valuePairText("Chance", s.Chance, "; ")
				if t then table.insert(detail, t) end
			end

			if s["Fixed Duration"] then
				table.insert(detail, "Fixed duration")
			end

			if #detail > 0 then
				seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
			end

			table.insert(parts, seg)
		end
	end
	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatStatusRemoval(list)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end
	local parts = {}
	for _, r in ipairs(list) do
		if type(r) == "table" then
			local names = r["Status External Name"]
			local label
			if type(names) == "table" then
				label = table.concat(names, ", ")
			elseif type(names) == "string" then
				label = names
			else
				label = "Status"
			end

			local amt = valuePairRawText(r)
			local seg = label
			if amt then
				seg = seg .. " – " .. amt
			end
			table.insert(parts, seg)
		end
	end
	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

local function formatEvents(list)
	if type(list) ~= "table" or #list == 0 then
		return nil
	end
	local parts = {}
	for _, ev in ipairs(list) do
		if type(ev) == "table" then
			local action = ev.Action or "On event"
			local name   = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
			table.insert(parts, string.format("%s → %s", action, name))
		end
	end
	if #parts == 0 then
		return nil
	end
	return table.concat(parts, "<br />")
end

----------------------------------------------------------------------
-- User matching (for auto lists on class pages)
----------------------------------------------------------------------

local function skillMatchesUser(rec, userName)
	if type(rec) ~= "table" or not userName or userName == "" then
		return false
	end

	local users = rec.Users
	if type(users) ~= "table" then
		return false
	end

	local userLower = mw.ustring.lower(userName)

	local function listHas(list)
		if type(list) ~= "table" then
			return false
		end
		for _, v in ipairs(list) do
			if type(v) == "string" and mw.ustring.lower(v) == userLower then
				return true
			end
		end
		return false
	end

	if listHas(users.Classes)  then return true end
	if listHas(users.Summons)  then return true end
	if listHas(users.Monsters) then return true end
	if listHas(users.Events)   then return true end

	return false
end

----------------------------------------------------------------------
-- Direct page detection (hide Users on the skill's own page)
----------------------------------------------------------------------

local function isDirectSkillPage(rec)
	if type(rec) ~= "table" then
		return false
	end

	local pageTitle = mw.title.getCurrentTitle()
	local pageName = pageTitle and pageTitle.text or ""
	pageName = trim(pageName)
	if not pageName then
		return false
	end
	pageName = mw.ustring.lower(pageName)

	local ext = trim(rec["External Name"] or rec["Name"] or rec["Display Name"])
	local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])

	if ext and mw.ustring.lower(ext) == pageName then
		return true
	end
	if internal and mw.ustring.lower(internal) == pageName then
		return true
	end
	return false
end

----------------------------------------------------------------------
-- Infobox builder
----------------------------------------------------------------------

local function buildInfobox(rec, opts)
	opts = opts or {}
	local showUsers = (opts.showUsers ~= false)

	local root = mw.html.create("table")
	root:addClass("wikitable spiritvale-skill-infobox")

	-- ==========================================================
	-- Top "hero" row: icon + name (left), description (right)
	-- ==========================================================
	local icon  = rec.Icon
	local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
	local desc  = rec.Description or ""

	local headerRow = root:tag("tr")
	headerRow:addClass("spiritvale-infobox-main")

	local leftCell = headerRow:tag("th")
	leftCell:addClass("spiritvale-infobox-main-left")

	local leftInner = leftCell:tag("div")
	leftInner:addClass("spiritvale-infobox-main-left-inner")

	if icon and icon ~= "" then
		leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
	end

	leftInner:tag("div")
		:addClass("spiritvale-infobox-title")
		:wikitext(title)

	local rightCell = headerRow:tag("td")
	rightCell:addClass("spiritvale-infobox-main-right")

	local rightInner = rightCell:tag("div")
	rightInner:addClass("spiritvale-infobox-main-right-inner")

	if desc ~= "" then
		rightInner:tag("div")
			:addClass("spiritvale-infobox-description")
			:wikitext(string.format("''%s''", desc))
	end

	------------------------------------------------------------------
	-- General
	------------------------------------------------------------------
	addSectionHeader(root, "General")
	addRow(root, "Max Level", rec["Max Level"] and tostring(rec["Max Level"]))

	-- Hide Users on:
	--  - list pages (opts.showUsers=false)
	--  - the skill's own page (handled by caller)
	if showUsers then
		local users = rec.Users or {}
		addRow(root, "Classes",  listToText(users.Classes))
		addRow(root, "Summons",  listToText(users.Summons))
		addRow(root, "Monsters", listToText(users.Monsters))
		addRow(root, "Events",   listToText(users.Events))
	end

	------------------------------------------------------------------
	-- Requirements
	------------------------------------------------------------------
	local req = rec.Requirements or {}
	if (req["Required Skills"] and #req["Required Skills"] > 0)
		or (req["Required Weapons"] and #req["Required Weapons"] > 0)
		or (req["Required Stances"] and #req["Required Stances"] > 0) then

		addSectionHeader(root, "Requirements")

		if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
			local skillParts = {}
			for _, rs in ipairs(req["Required Skills"]) do
				local name  = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
				local level = rs["Required Level"]
				if level then
					table.insert(skillParts, string.format("%s (Lv.%s)", name, level))
				else
					table.insert(skillParts, name)
				end
			end
			addRow(root, "Required Skills", table.concat(skillParts, ", "))
		end

		addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
		addRow(root, "Required Stances", listToText(req["Required Stances"]))
	end

	------------------------------------------------------------------
	-- Type
	------------------------------------------------------------------
	local typeBlock = rec.Type or {}
	if next(typeBlock) ~= nil then
		addSectionHeader(root, "Type")

		local dt = typeBlock["Damage Type"]
		if type(dt) == "table" and dt.Name then
			addRow(root, "Damage Type", dt.Name)
		end

		local et = typeBlock["Element Type"]
		if type(et) == "table" and et.Name then
			addRow(root, "Element", et.Name)
		end

		local tt = typeBlock["Target Type"]
		if type(tt) == "table" and tt.Name then
			addRow(root, "Target", tt.Name)
		end

		local ct = typeBlock["Cast Type"]
		if type(ct) == "table" and ct.Name then
			addRow(root, "Cast Type", ct.Name)
		end
	end

	------------------------------------------------------------------
	-- Mechanics
	------------------------------------------------------------------
	local mech = rec.Mechanics or {}
	if next(mech) ~= nil then
		addSectionHeader(root, "Mechanics")

		local rangeText = formatUnitValue(mech.Range)
		addRow(root, "Range", rangeText)

		local areaText = formatArea(mech.Area)
		addRow(root, "Area", areaText)

		if mech["Autocast Multiplier"] ~= nil then
			addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
		end

		local btText = formatTimingBlock(mech["Basic Timings"])
		addRow(root, "Timing", btText)

		local rcText = formatResourceCost(mech["Resource Cost"])
		addRow(root, "Resource Cost", rcText)

		local comboText = formatCombo(mech.Combo)
		addRow(root, "Combo", comboText)

		local effText = formatMechanicEffects(mech.Effects)
		addRow(root, "Special Mechanics", effText)
	end

	------------------------------------------------------------------
	-- Damage & Scaling
	------------------------------------------------------------------
	local dmg = rec.Damage or {}
	if next(dmg) ~= nil then
		addSectionHeader(root, "Damage and Scaling")

		local maxLevel = tonumber(rec["Max Level"]) or 0

		-- Split healing out of Main Damage (Type == "Healing")
		local main = dmg["Main Damage"]
		local mainNonHeal = {}
		local healOnly = {}

		if type(main) == "table" then
			for _, d in ipairs(main) do
				if type(d) == "table" and d.Type == "Healing" then
					table.insert(healOnly, d)
				else
					table.insert(mainNonHeal, d)
				end
			end
		end

		local flatList = dmg["Flat Damage"]
		local reflList = dmg["Reflect Damage"]

		local flatHas = (type(flatList) == "table" and #flatList > 0)
		local reflHas = (type(reflList) == "table" and #reflList > 0)

		-- Determine if this is effectively a "pure healing" skill for scaling wording.
		local pureHealing = (#healOnly > 0) and (#mainNonHeal == 0) and (not flatHas) and (not reflHas)

		local mainText = formatDamageList(mainNonHeal, maxLevel, (#mainNonHeal > 1), false)
		addRow(root, "Main Damage", mainText)

		local flatText = formatDamageList(flatList, maxLevel, false, false)
		addRow(root, "Flat Damage", flatText)

		local reflText = formatDamageList(reflList, maxLevel, false, false)
		addRow(root, "Reflect Damage", reflText)

		local healText = formatDamageList(healOnly, maxLevel, false, true)
		addRow(root, "Healing", healText)

		local scaleText = formatScaling(dmg.Scaling, pureHealing and "Healing" or nil)
		addRow(root, "Scaling", scaleText)
	end

	------------------------------------------------------------------
	-- Modifiers
	------------------------------------------------------------------
	local modsText = formatModifiers(rec.Modifiers)
	if modsText then
		addSectionHeader(root, "Modifiers")
		addRow(root, "Flags", modsText)
	end

	------------------------------------------------------------------
	-- Status
	------------------------------------------------------------------
	local statusApps = formatStatusApplications(rec["Status Applications"])
	local statusRem  = formatStatusRemoval(rec["Status Removal"])
	if statusApps or statusRem then
		addSectionHeader(root, "Status Effects")
		addRow(root, "Applies", statusApps)
		addRow(root, "Removes", statusRem)
	end

	------------------------------------------------------------------
	-- Events
	------------------------------------------------------------------
	local eventsText = formatEvents(rec.Events)
	if eventsText then
		addSectionHeader(root, "Events")
		addRow(root, "Triggers", eventsText)
	end

	------------------------------------------------------------------
	-- Notes
	------------------------------------------------------------------
	if type(rec.Notes) == "table" and #rec.Notes > 0 then
		addSectionHeader(root, "Notes")
		addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
	end

	return tostring(root)
end

----------------------------------------------------------------------
-- Public: list all skills for a given user/class
----------------------------------------------------------------------

function p.listForUser(frame)
	local args = getArgs(frame)

	-- Prefer explicit param, then unnamed, then fall back to the current page name.
	local userName = args.user or args[1]
	if not userName or userName == "" then
		userName = mw.title.getCurrentTitle().text
	end

	if not userName or userName == "" then
		return "<strong>No user name provided to Skill list.</strong>"
	end

	local dataset = getSkills()
	local matches = {}

	for _, rec in ipairs(dataset.records or {}) do
		if skillMatchesUser(rec, userName) then
			table.insert(matches, rec)
		end
	end

	if #matches == 0 then
		return string.format(
			"<strong>No skills found for:</strong> %s",
			mw.text.nowiki(userName)
		)
	end

	local root = mw.html.create("div")
	root:addClass("spiritvale-skill-list")

	-- On class pages / list mode, hide Users (redundant on that page).
	for _, rec in ipairs(matches) do
		root:wikitext(buildInfobox(rec, { showUsers = false }))
	end

	return tostring(root)
end

----------------------------------------------------------------------
-- Public: single-skill or auto-list dispatcher
----------------------------------------------------------------------

function p.infobox(frame)
	local args = getArgs(frame)

	-- Allow three styles:
	--   {{Skill|Bash}}              -> args[1] = "Bash"  (External Name)
	--   {{Skill|name=Bash}}         -> args.name = "Bash"
	--   {{Skill|id=Bash_Internal}}  -> args.id = "Bash_Internal"
	local raw1 = args[1]
	local name = args.name or raw1
	local id   = args.id

	local rec

	-- 1) Prefer External/Display Name
	if name and name ~= "" then
		rec = findSkillByName(name)
	end

	-- 2) Fallback: internal ID
	if not rec and id and id ~= "" then
		rec = getSkillById(id)
	end

	-- 3) If still nothing, decide if this is "list mode" or truly unknown.
	if not rec then
		local pageTitle = mw.title.getCurrentTitle()
		local pageName  = pageTitle and pageTitle.text or ""

		local noExplicitArgs =
			(not raw1 or raw1 == "") and
			(not args.name or args.name == "") and
			(not id or id == "")

		-- Case A: {{Skill}} with no parameters on a page → list for that page name.
		if noExplicitArgs then
			return p.listForUser(frame)
		end

		-- Case B: {{Skill|Acolyte}} on the "Acolyte" page and no id → treat as list.
		if name and name ~= "" and name == pageName and (not id or id == "") then
			return p.listForUser(frame)
		end

		-- Otherwise, genuinely unknown skill.
		local label = name or id or "?"
		return string.format(
			"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
			mw.text.nowiki(label),
			label
		)
	end

	-- For single-skill rendering:
	-- - hide Users if this is the skill's own page
	-- - otherwise show Users
	local showUsers = not isDirectSkillPage(rec)
	return buildInfobox(rec, { showUsers = showUsers })
end

return p