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.
Level Select Level 10 / 10 Type Melee Element Neutral Target Enemy Cast Type Target
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Resource Cost	MP: 13
Combo	Type: Ready, Duration: 4s
Main Damage	350% Attack
Scaling	2% Attack Per Strength
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 30%)

or, explicitly:

Bash
Delivers a crushing blow with a chance to stun the target.
Level Select Level 10 / 10 Type Melee Element Neutral Target Enemy Cast Type Target
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Resource Cost	MP: 13
Combo	Type: Ready, Duration: 4s
Main Damage	350% Attack
Scaling	2% Attack Per Strength
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 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
--
-- Upgrades:
--  - Adds a per-skill Level Select slider (client-side JS updates fields)
--  - Default level = Max Level
--  - Adds .sv-skill-card + data-max-level / data-level hooks for JS
--  - Replaces large Lv1/Lv2/... lists with data-series dynamic spans
--  - Removes "General" + "Type" section bars and merges Level Select + Type into one unified top band
--    (Level Select on the left; Type/Element/Target/Cast Type on the right)
--  - NEW (list-mode): Wraps all skills in ONE wrapper panel and each skill in a stable .sv-skill-item
--    so CSS dividers work reliably under Citizen/table wrappers.
--
-- Requires the JS you installed in MediaWiki:Common.js.
-- Uses Common.css classes:
--   .sv-topband-cell, .sv-topband-table, .sv-type-grid, .sv-type-chunk, .sv-type-label, .sv-type-value
--   .sv-level-ui, .sv-level-title, .sv-level-label, .sv-level-slider
--   .sv-skill-collection, .sv-skill-item

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
	if type(v) == "table" and v.Value ~= nil then
		return toNum(v.Value)
	end
	return nil
end

local function clamp(n, lo, hi)
	if type(n) ~= "number" then
		return lo
	end
	if n < lo then
		return lo
	end
	if n > hi then
		return hi
	end
	return n
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

----------------------------------------------------------------------
-- Dynamic field helpers (JS-driven)
----------------------------------------------------------------------

local function dynSpan(series, level)
	if type(series) ~= "table" or #series == 0 then
		return nil
	end

	level = clamp(level or #series, 1, #series)

	local span = mw.html.create("span")
	span:addClass("sv-dyn")
	span:attr("data-series", mw.text.jsonEncode(series))
	span:wikitext(mw.text.nowiki(series[level] or ""))

	return tostring(span)
end

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

-- Like your old valuePairLines/valuePairText, but:
-- - if Per Level is a list, render a dynamic span instead of "v1 / v2 / ..."
-- - scalar Per Level stays as the old "Base" + "Per Level" lines (still short)
local function valuePairDynamicLines(name, block, maxLevel, level)
	if type(block) ~= "table" then
		return {}
	end

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

	-- Per Level list (expanded)
	if type(per) == "table" then
		-- empty list -> show Base only
		if #per == 0 then
			local baseText = formatUnitValue(base)
			if baseText then
				return { string.format("%s: %s", name, mw.text.nowiki(baseText)) }
			end
			return {}
		end

		-- flat list -> show single value
		if isFlatList(per) then
			local baseText = formatUnitValue(base)
			local one = formatUnitValue(per[1]) or tostring(per[1])
			local show = baseText or one
			if show then
				return { string.format("%s: %s", name, mw.text.nowiki(show)) }
			end
			return {}
		end

		-- dynamic series
		local series = {}
		for _, v in ipairs(per) do
			table.insert(series, formatUnitValue(v) or tostring(v))
		end

		local dyn = dynSpan(series, level)
		if dyn then
			return { string.format("%s: %s", name, dyn) }
		end
		return {}
	end

	-- scalar Per Level (keep old style)
	local lines = {}
	local baseText = formatUnitValue(base)
	local perText  = formatUnitValue(per)

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

	return lines
end

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

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

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

local function findSkillByName(name)
	name = trim(name)
	if not name then
		return nil
	end

	local dataset = getSkills()
	local byName = dataset.byName or {}

	if byName[name] then
		return byName[name]
	end

	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 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

-- Dynamic damage entry:
-- Build a series for Lv1..LvMax, and show only the selected one.
local function formatDamageEntry(entry, maxLevel, level)
	if type(entry) ~= "table" then
		return nil
	end

	local isHealing = (entry.Type == "Healing")
	local basis = isHealing and "Healing" or basisLabel(entry)

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

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

	local function baseIsPresent()
		if baseN ~= nil then
			return baseN ~= 0
		end
		if baseRaw ~= nil then
			local s = tostring(baseRaw)
			return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
		end
		return false
	end

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

	-- No scaling -> just show base
	if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
		return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil
	end

	-- Build series strings for each level
	local series = {}
	for lv = 1, maxLevel do
		local perPart = perN * lv

		if baseText and baseN ~= nil then
			local total = baseN + perPart
			table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
		elseif baseText then
			table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
		else
			table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
		end
	end

	return dynSpan(series, level)
end

local function formatDamageList(list, maxLevel, level, includeTypePrefix)
	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, level)
			if txt then
				if includeTypePrefix and d.Type and d.Type ~= "" then
					table.insert(parts, mw.text.nowiki(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

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

local function formatArea(area, maxLevel, level)
	if type(area) ~= "table" then
		return nil
	end

	local parts = {}

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

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

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

local function formatTimingBlock(bt, maxLevel, level)
	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 = valuePairDynamicLines(label, block, maxLevel, level)
		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: " .. mw.text.nowiki(tostring(bt["Effect Cast Time"])))
	end
	if bt["Damage Delay"] ~= nil then
		table.insert(parts, "Damage Delay: " .. mw.text.nowiki(tostring(bt["Damage Delay"])))
	end
	if bt["Effect Remove Delay"] ~= nil then
		table.insert(parts, "Effect Remove Delay: " .. mw.text.nowiki(tostring(bt["Effect Remove Delay"])))
	end

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

local function formatResourceCost(rc, maxLevel, level)
	if type(rc) ~= "table" then
		return nil
	end

	local parts = {}

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

	local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
	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: " .. mw.text.nowiki(tostring(combo.Type)))
	end

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

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

	if #parts == 0 then
		return nil
	end
	return table.concat(parts, ", ")
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

-- Special Mechanics supports dynamic Per Level lists
local function formatMechanicEffects(effects, maxLevel, level)
	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 = {}

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

		local per = block["Per Level"]
		if type(per) == "table" and #per > 0 then
			if isFlatList(per) then
				return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
			end
			local series = {}
			for _, v in ipairs(per) do
				table.insert(series, formatUnitValue(v) or tostring(v))
			end
			return dynSpan(series, level)
		end

		local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
		local txt = valuePairRawText(pair)
		return txt and mw.text.nowiki(txt) or nil
	end

	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 amt = effectAmount(block)
				local seg = mw.text.nowiki(tostring(t) .. " - " .. tostring(name))
				if amt then
					seg = seg .. " + " .. amt
				end
				table.insert(parts, seg)
			else
				local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
				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, maxLevel, level)
	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 = valuePairDynamicText("Duration", s.Duration, maxLevel, level, "; ")
				if t then
					table.insert(detail, t)
				end
			end

			if type(s.Chance) == "table" then
				local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
				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, maxLevel, level)
	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 = nil
			if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
				local series = {}
				for _, v in ipairs(r["Per Level"]) do
					table.insert(series, formatUnitValue(v) or tostring(v))
				end
				amt = dynSpan(series, level)
			else
				amt = valuePairRawText(r)
				if amt then
					amt = mw.text.nowiki(amt)
				end
			end

			local seg = mw.text.nowiki(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 (Top band: Level Select + Type)
----------------------------------------------------------------------

local function buildLevelSelectUI(level, maxLevel)
	-- JS expectations:
	--   .sv-level-slider => placeholder for the <input type="range">
	--   .sv-level-num    => span for updating the number
	local wrap = mw.html.create("div")
	wrap:addClass("sv-level-ui")

	wrap:tag("div")
		:addClass("sv-level-title")
		:wikitext("Level Select")

	wrap:tag("div")
		:addClass("sv-level-label")
		:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))

	wrap:tag("div"):addClass("sv-level-slider")

	return tostring(wrap)
end

local function buildTypeTableUI(typeBlock)
	if type(typeBlock) ~= "table" or next(typeBlock) == nil then
		return nil
	end

	local wrap = mw.html.create("div")
	wrap:addClass("sv-type-grid")

	local added = false

	local function valName(x)
		if x == nil then
			return nil
		end
		if type(x) == "table" then
			if x.Name and x.Name ~= "" then return tostring(x.Name) end
			if x.ID and x.ID ~= "" then return tostring(x.ID) end
		end
		if type(x) == "string" and x ~= "" then
			return x
		end
		return nil
	end

	local function addChunk(label, rawVal)
		local v = valName(rawVal)
		if not v or v == "" then
			return
		end
		added = true

		local chunk = wrap:tag("div"):addClass("sv-type-chunk")
		chunk:tag("div"):addClass("sv-type-label"):wikitext(mw.text.nowiki(label))
		chunk:tag("div"):addClass("sv-type-value"):wikitext(mw.text.nowiki(v))
	end

	addChunk("Type",      typeBlock["Damage Type"])
	addChunk("Element",   typeBlock["Element Type"])
	addChunk("Target",    typeBlock["Target Type"])
	addChunk("Cast Type", typeBlock["Cast Type"])

	if not added then
		return nil
	end

	return tostring(wrap)
end

local function addTopBand(tbl, levelUI, typeUI)
	if not levelUI and not typeUI then
		return
	end

	local row = tbl:tag("tr")
	local cell = row:tag("td")
	cell:attr("colspan", 2)
	cell:addClass("sv-topband-cell")

	-- Nested table (what Common.css targets)
	local inner = cell:tag("table")
	inner:addClass("sv-topband-table")

	local tr = inner:tag("tr")

	if levelUI and typeUI then
		tr:tag("td"):wikitext(levelUI):done()
		tr:tag("td"):wikitext(typeUI):done()
	elseif levelUI then
		tr:tag("td"):attr("colspan", 2):wikitext(levelUI):done()
	else
		tr:tag("td"):attr("colspan", 2):wikitext(typeUI):done()
	end
end

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

	local maxLevel = tonumber(rec["Max Level"]) or 1
	if maxLevel < 1 then
		maxLevel = 1
	end

	-- Always default to max level
	local level = clamp(maxLevel, 1, maxLevel)

	local root = mw.html.create("table")

	-- IMPORTANT:
	-- Don't use "wikitable" here; it triggers default borders + Citizen wrapper styling.
	root:addClass("spiritvale-skill-infobox")

	-- JS hook: treat the table itself as the "card"
	root:addClass("sv-skill-card")
	root:attr("data-max-level", tostring(maxLevel))
	root:attr("data-level", tostring(level))

	-- Helpful flag for list-mode overrides (optional)
	if opts.inList then
		root:addClass("sv-skill-inlist")
	end

	-- Top "hero" rows:
	-- 1) Title row: icon + name centered (single cell)
	-- 2) Description row: its own row below (still part of hero band)
	local icon  = rec.Icon
	local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
	local desc  = rec.Description or ""

	-- Row 1: icon + title (single column)
	local heroRow = root:tag("tr")
	heroRow:addClass("spiritvale-infobox-main")
	heroRow:addClass("sv-hero-title-row")

	local heroCell = heroRow:tag("th")
	heroCell:attr("colspan", 2)
	heroCell:addClass("sv-hero-title-cell")

	local heroInner = heroCell:tag("div")
	heroInner:addClass("spiritvale-infobox-main-left-inner") -- reuse centered flex column

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

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

	-- Row 2: description (below, still hero-styled)
	if desc ~= "" then
		local descRow = root:tag("tr")
		descRow:addClass("spiritvale-infobox-main")
		descRow:addClass("sv-hero-desc-row")

		local descCell = descRow:tag("td")
		descCell:attr("colspan", 2)
		descCell:addClass("sv-hero-desc-cell")

		local descInner = descCell:tag("div")
		descInner:addClass("spiritvale-infobox-main-right-inner")

		descInner:tag("div")
			:addClass("spiritvale-infobox-description")
			:wikitext(string.format("''%s''", desc))
	end

	------------------------------------------------------------------
	-- Unified top band (Level Select left, Type list right)
	------------------------------------------------------------------
	local levelUI = buildLevelSelectUI(level, maxLevel)
	local typeUI  = buildTypeTableUI(rec.Type or {})
	addTopBand(root, levelUI, typeUI)

	------------------------------------------------------------------
	-- Users (kept as rows; caller decides show/hide)
	------------------------------------------------------------------
	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

		if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
			local skillParts = {}
			for _, rs in ipairs(req["Required Skills"]) do
				local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
				local lvlReq  = rs["Required Level"]
				if lvlReq then
					table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
				else
					table.insert(skillParts, nameReq)
				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

	------------------------------------------------------------------
	-- Mechanics
	------------------------------------------------------------------
	local mech = rec.Mechanics or {}
	if next(mech) ~= nil then
		addRow(root, "Range", formatUnitValue(mech.Range))
		addRow(root, "Area",  formatArea(mech.Area, maxLevel, level))

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

		addRow(root, "Timing",         formatTimingBlock(mech["Basic Timings"], maxLevel, level))
		addRow(root, "Resource Cost",  formatResourceCost(mech["Resource Cost"], maxLevel, level))
		addRow(root, "Combo",          formatCombo(mech.Combo))
		addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
	end

	------------------------------------------------------------------
	-- Damage & Scaling
	------------------------------------------------------------------
	local dmg = rec.Damage or {}
	if next(dmg) ~= nil then
		local main = dmg["Main Damage"]
		local mainNonHeal, 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)

		local pureHealing = (#healOnly > 0) and (#mainNonHeal == 0) and (not flatHas) and (not reflHas)

		addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)))
		addRow(root, "Flat Damage",    formatDamageList(flatList, maxLevel, level, false))
		addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false))
		addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false))

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

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

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

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

	------------------------------------------------------------------
	-- Notes
	------------------------------------------------------------------
	if type(rec.Notes) == "table" and #rec.Notes > 0 then
		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)

	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

	-- ONE wrapper panel (table-like list mode)
	local root = mw.html.create("div")
	root:addClass("sv-skill-collection")

	for _, rec in ipairs(matches) do
		-- Stable per-skill wrapper so dividers work even under Citizen wrappers
		local item = root:tag("div"):addClass("sv-skill-item")
		item:wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
	end

	return tostring(root)
end

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

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

	local raw1 = args[1]
	local name = args.name or raw1
	local id   = args.id

	local rec
	if name and name ~= "" then
		rec = findSkillByName(name)
	end
	if not rec and id and id ~= "" then
		rec = getSkillById(id)
	end

	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 == "")

		if noExplicitArgs then
			return p.listForUser(frame)
		end

		if name and name ~= "" and name == pageName and (not id or id == "") then
			return p.listForUser(frame)
		end

		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

	local showUsers = not isDirectSkillPage(rec)
	return buildInfobox(rec, { showUsers = showUsers })
end

return p