Module:AutoUpdateServPrices

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

---------------------------------------------------------
-- Module:AutoUpdateServPrices (OPTIMIZED)
--
-- Fix for Scribunto timeout:
--  • Caches city-level signals once per unique HQ city:
--      - Forecast opsData
--      - Hatch daily report city counts (one report per day; counts cached)
--      - War League table city counts (one table per day; counts cached)
--      - Outbreak severity (one call per city; cached)
--  • Avoids repeated string concatenation in loops (uses table buffers).
--  • Keeps same output format and pricing logic as the previous rewrite.
---------------------------------------------------------
local p = {}

---------------------------------------------------------
-- getCurrentDate
---------------------------------------------------------
local function getCurrentDate()
	local startDate = os.time({ year = 1999, month = 8, day = 6 })
	local secondsInDay = 86400
	local daysPerYear = 183
	local currentDate = os.time()
	local totalDaysElapsed = math.floor((currentDate - startDate) / secondsInDay)
	local yearFraction = totalDaysElapsed / daysPerYear
	local psscYear = math.floor(yearFraction)
	local dayOfYear = math.floor((yearFraction - psscYear) * daysPerYear) + 1

	local month, dayOfMonth
	if dayOfYear <= 61 then
		month = 1
		dayOfMonth = dayOfYear
	elseif dayOfYear <= 122 then
		month = 2
		dayOfMonth = dayOfYear - 61
	else
		month = 3
		dayOfMonth = dayOfYear - 122
	end

	return string.format("%d/%d/%d [[PSSC]]", dayOfMonth, month, psscYear), dayOfMonth, month, psscYear, dayOfYear
end

---------------------------------------------------------
-- Product data (FULL LIST — from oldid=380847)
---------------------------------------------------------
local products = mw.loadData("Module:AutoUpdateServPrices/Data")

---------------------------------------------------------
-- City-Signal Integrations
---------------------------------------------------------
local forecastOk, forecast = pcall(require, "Module:BassaridiaForecast")
local hatchOk, hatch = pcall(require, "Module:HatchMinistryDailyOps")
local outbreakOk, outbreaks = pcall(require, "Module:BassaridiaOutbreaks")
local warOk, war = pcall(require, "Module:WarLeagueDivisionOpsBVR")

local function escapePattern(s)
	s = tostring(s or "")
	return s:gsub("([%%%^%$%(%)%.%[%]%*%+%-%?])", "%%%1")
end

local function normalizeCompany(company)
	company = tostring(company or "")
	company = company:gsub("%s+$", "")
	company = company:gsub("%*$", "")
	company = company:gsub("%s+$", "")
	return company
end

local companyHQOverrides = {
	["Hatch Ministry"] = "Vaeringheim",
	["Lake Morovia Blockade Fund - Hatch Ministry"] = "Vaeringheim",
	["Maritime Guild of the Cult of Maskmakers"] = "Jogi",
	["Ergonian Spy Agency"] = "Jogi",
	["Temple Bank of the Reformed Stripping Path"] = "Vaeringheim",
	["Couriers of the Lizard Queen"] = "Delphica",
	["Temple University of Delphica"] = "Delphica",
	["La Sái Ebile"] = "Erythros",
	["Trans-Morovian Express"] = "Riddersborg",
	["Hellhound Breeders of Dragevik"] = "Dragevik",
	["Pharmacon Sect"] = "Acheron",
	["Skyrophian Security Contractors"] = "Skýrophos",
	["Haifadora Postal Service"] = "Vaeringheim",
	["Fleet of Rouge Divers"] = "Rouge",
	["Merchant Caravans of the Candy Kingdom"] = "Butterscotch",
	["Bassaridian Broadcasting Corporation"] = "Vaeringheim",
	["Temple of Aprobelle"] = "Vaeringheim",
	["Keltian Steppe Caravan Company"] = "Tonar",
	["Sårensby Depot"] = "Sårensby",
	["Haifa Compliance Exchange"] = "Vaeringheim",
	["Port of Corumia"] = "",
	["Pentiad Terminal Operations"] = "Vaeringheim",
	["Pentiad Terminal Operations Agency"] = "Vaeringheim",
	["Azat Tug and Pilot Cooperative"] = "Vaeringheim",
	["Calliope Shipyard Repair Agency"] = "Vaeringheim",
	["Bulhanu Maritime Insurance Association"] = "Vaeringheim",
	["Morovian Customs & Freight Syndicate"] = "Vaeringheim",
	["Morovian Sanitation and Bilge Company"] = "Vaeringheim",
	["Ordo Ebríumä Oneira (Highland Guides)"] = "",
	["Lothayan Skybridge Airways"] = "Vaeringheim",
}

local function inferHQCity(companyName)
	local c = normalizeCompany(companyName)
	return companyHQOverrides[c] or ""
end

local function clamp(x, lo, hi)
	if x < lo then return lo end
	if x > hi then return hi end
	return x
end

local function opsLevelToNumber(levelOrLabel)
	local n = tonumber(levelOrLabel)
	if n then return n end
	local t = tostring(levelOrLabel or ""):lower()
	if t:find("green") then return 0 end
	if t:find("yellow") then return 1 end
	if t:find("orange") then return 2 end
	if t:find("red") then return 3 end
	return 0
end

local function productClassServ(productName, companyName)
	local n = tostring(productName or ""):lower()
	local c = normalizeCompany(companyName):lower()

	if n:find("sanitation") or n:find("bilge") or n:find("quarantine") or n:find("decontamination")
		or n:find("medical") or n:find("pathogen") or n:find("chlorination") or n:find("hygiene") or n:find("abatement")
		or n:find("customs") or n:find("clearance") or n:find("tariff") or n:find("bonded") or n:find("freight")
		or n:find("pilotage") or n:find("tug") or n:find("berth") or n:find("stevedoring") or n:find("intermodal")
		or n:find("escort") or n:find("security") or n:find("risk") or n:find("insurance") or n:find("arbitration")
		or n:find("postal") or n:find("delivery") or n:find("courier")
		or c:find("sanitation") or c:find("customs") or c:find("insurance") or c:find("terminal") or c:find("tug")
	then
		return "essential"
	end

	if c:find("aprobelle") or n:find("loyalty") or n:find("behavior") or n:find("polygraph") or n:find("anomaly") then
		return "governance"
	end

	if n:find("circus") or n:find("performance") or n:find("parade") or n:find("tickets") or n:find("tour")
		or n:find("cabin") or n:find("luxury") or n:find("advert") or n:find("sponsorship") or n:find("broadcast")
		or n:find("salvaged") or n:find("antique") or n:find("treasure") or n:find("jewelry") or n:find("artifact")
		or c:find("divers") or c:find("candy") or c:find("broadcasting")
	then
		return "discretionary"
	end

	if c:find("hatch ministry") or c:find("blockade fund") then
		return "volatile"
	end

	return "standard"
end

-- Cache tables (filled per generateTable call)
local cache = {
	forecast = {},   -- city -> {mult,note,opsLevel}
	war = {},        -- city -> {mult,note} (depends on opsLevel + war count)
	hatchCount = {}, -- city -> integer
	health = {},     -- city -> {mult,severity,note}
}

local function getForecastSignal(city, year, dayOfYear)
	local v = cache.forecast[city]
	if v then return v end

	if not (forecastOk and forecast and type(forecast.getOpsData) == "function") then
		v = { mult = 0, note = nil, opsLevel = 0 }
		cache.forecast[city] = v
		return v
	end

	local op = forecast.getOpsData(city, year, dayOfYear)
	if not op or not op.alert or not op.impacts then
		v = { mult = 0, note = nil, opsLevel = 0 }
		cache.forecast[city] = v
		return v
	end

	local m = 0
	local ground = tostring(op.impacts.ground or "OK")
	local sea    = tostring(op.impacts.sea or "OK")
	local air    = tostring(op.impacts.air or "OK")

	if ground == "Slow" then m = m + 0.02
	elseif ground == "Closed" then m = m + 0.08 end

	if sea == "Restricted" then m = m + 0.03
	elseif sea == "Closed" then m = m + 0.06 end

	if air == "Limited" then m = m + 0.01
	elseif air == "No-Go" then m = m + 0.04 end

	local cond = tostring(op.condition or "")
	local lc = cond:lower()
	if lc:find("blizzard") then m = m + 0.05
	elseif lc:find("storm") then m = m + 0.03
	elseif lc:find("fog") then m = m + 0.02
	elseif lc:find("rain") then m = m + 0.01 end

	local opsLevel = opsLevelToNumber(op.alert.level)
	local note = string.format("WX/Ops %s (%s; G:%s S:%s A:%s)", tostring(op.alert.label or ""), cond, ground, sea, air)

	v = { mult = m, note = note, opsLevel = opsLevel }
	cache.forecast[city] = v
	return v
end

-- Precompute hatch city counts once (one report render + per-city pattern counts only for cities we need)
local hatchReportText = nil
local function getHatchCityCount(city, year, dayOfYear)
	local v = cache.hatchCount[city]
	if v ~= nil then return v end

	if not hatchReportText then
		if hatchOk and hatch and type(hatch.dailyReport) == "function" then
			hatchReportText = tostring(hatch.dailyReport({ args = { year = tostring(year), day = tostring(dayOfYear), legend = "no" } }) or "")
		else
			hatchReportText = ""
		end
	end

	local needle = "%[%[List_of_cities_in_Bassaridia_Vaeringheim#" .. escapePattern(city) .. "%|" .. escapePattern(city) .. "%]%]"
	local c = 0
	for _ in hatchReportText:gmatch(needle) do c = c + 1 end
	cache.hatchCount[city] = c
	return c
end

local warTableText = nil
local function getWarCityCount(city, year, dayOfYear)
	-- store under hatchCount? no; just compute per city using warTableText, but keep as cache.warCount
	cache.warCount = cache.warCount or {}
	local v = cache.warCount[city]
	if v ~= nil then return v end

	if not warTableText then
		if warOk and war and type(war.makeTable) == "function" then
			warTableText = tostring(war.makeTable({ args = { rows = "48", showlegend = "no", seed = tostring(year * 1000 + dayOfYear) } }) or "")
		else
			warTableText = ""
		end
	end

	local needle = "%[%[List_of_cities_in_Bassaridia_Vaeringheim#" .. escapePattern(city) .. "%|" .. escapePattern(city) .. "%]%]"
	local c = 0
	for _ in warTableText:gmatch(needle) do c = c + 1 end
	cache.warCount[city] = c
	return c
end

local function getHatchSignal(city, year, dayOfYear)
	local n = getHatchCityCount(city, year, dayOfYear)
	if n <= 0 then return { mult = 0, note = nil } end
	local m = math.min(0.05, n * 0.005)
	return { mult = m, note = string.format("Hatch activity %d (≈+%.1f%%)", n, m*100) }
end

local function parseOutbreakSeverity(outText)
	outText = tostring(outText or "")
	local sev = outText:match('style="background:[^"]+"%s*|%s*([A-Z]+)%s*||')
	if sev == "CRITICAL" or sev == "HIGH" or sev == "MEDIUM" or sev == "LOW" or sev == "NONE" then
		return sev
	end
	return "NONE"
end

local function getHealthSignal(city)
	local v = cache.health[city]
	if v then return v end

	if not (outbreakOk and outbreaks and type(outbreaks.outbreaksForCity) == "function") then
		v = { mult = 0, severity = "NONE", note = nil }
		cache.health[city] = v
		return v
	end

	local txt = outbreaks.outbreaksForCity({ args = { city = city } })
	local sev = parseOutbreakSeverity(txt)

	local m = 0
	if sev == "LOW" then m = 0.01
	elseif sev == "MEDIUM" then m = 0.03
	elseif sev == "HIGH" then m = 0.06
	elseif sev == "CRITICAL" then m = 0.10 end

	local note = (sev ~= "NONE") and ("Health " .. sev .. " (≈+" .. string.format("%.0f%%", m*100) .. ")") or nil
	v = { mult = m, severity = sev, note = note }
	cache.health[city] = v
	return v
end

local function getWarLeagueSignal(city, opsLevel, year, dayOfYear)
	-- war signal depends on opsLevel, so cache per city+opsLevel
	cache.war = cache.war or {}
	cache.war[city] = cache.war[city] or {}
	local v = cache.war[city][opsLevel]
	if v then return v end

	local m = 0
	if opsLevel == 1 then m = 0.01
	elseif opsLevel == 2 then m = 0.03
	elseif opsLevel >= 3 then m = 0.06 end

	local notes = {}
	if opsLevel > 0 then
		table.insert(notes, "War posture +" .. string.format("%.0f%%", m*100))
	end

	local c = getWarCityCount(city, year, dayOfYear)
	if c > 0 then
		local add = math.min(0.04, c * 0.003)
		m = m + add
		table.insert(notes, string.format("War League tempo %d (≈+%.1f%%)", c, add*100))
	end

	v = { mult = m, note = (#notes > 0) and table.concat(notes, "; ") or nil }
	cache.war[city][opsLevel] = v
	return v
end

local function getTempleBankSignal(pClass, healthSeverity, opsLevel)
	local crisis = (healthSeverity == "MEDIUM" or healthSeverity == "HIGH" or healthSeverity == "CRITICAL" or opsLevel >= 2)
	if not crisis then return { mult = 0, note = nil } end

	local m = 0
	if pClass == "essential" then
		if healthSeverity == "CRITICAL" then m = -0.04
		elseif healthSeverity == "HIGH" then m = -0.025
		else m = -0.015 end
		if opsLevel >= 3 then m = m - 0.01 end
		return { mult = m, note = string.format("Temple Bank stabilization (%.0f%%)", m*100) }
	elseif pClass == "governance" then
		if healthSeverity == "CRITICAL" or opsLevel >= 3 then m = 0.035
		elseif healthSeverity == "HIGH" or opsLevel >= 2 then m = 0.02
		else m = 0.01 end
		return { mult = m, note = string.format("Temple compliance demand (+%.0f%%)", m*100) }
	elseif pClass == "discretionary" then
		if healthSeverity == "CRITICAL" then m = 0.03
		elseif healthSeverity == "HIGH" then m = 0.02
		else m = 0.01 end
		return { mult = m, note = string.format("Temple market friction (+%.0f%%)", m*100) }
	else
		if opsLevel >= 3 or healthSeverity == "CRITICAL" then m = 0.02
		elseif opsLevel >= 2 or healthSeverity == "HIGH" then m = 0.01 end
		return { mult = m, note = (m ~= 0) and string.format("Temple finance friction (+%.0f%%)", m*100) or nil }
	end
end

---------------------------------------------------------
-- Special Date Events
---------------------------------------------------------
local events = {
	["1,6"]  = "Bayram al-Nur (Festival of Light) [Vaeringheim]",
	["1,18"] = "Chag Or Hadash (Festival of New Light) [Luminaria]",
	["1,30"] = "Symposion Eirinis (Symposium of Harmony) [Serena]",
	["1,43"] = "Alev Günü (Day of Flame) [Pyralis]",
	["1,48"] = "Day of Abandonment [Vaeringheim]",
	["1,55"] = "Tikkun Tzel (Repair of Shadows) [Symphonara]",
	["2,6"]  = "Panegyris Chrysou (Golden Gathering) [Aurelia]",
	["2,17"] = "Constitution Day [Luminaria]",
	["2,19"] = "Mehtap Dalgası (Moonlit Tide) [Vaeringheim]",
	["2,31"] = "Oneiro Foteino (Dream of Illumination) [Somniumpolis]",
	["2,39"] = "Anniversary of victory in the New South Jangsong Campaign [Nexa]",
	["2,44"] = "Erev Galgal (Eve of Cycles) [Nexa]",
	["2,45"] = "Bassaridia Festival [Somniumpolis]",
	["2,48"] = "Anniversary of victory in the Southern Lake Morovia Campaign [Somniumpolis]",
	["2,54"] = "Leilat al-Kamar (Night of the Moon) [Lunalis Sancta]",
	["2,61"] = "Taşrakah (Reverence of the Stone) [Luminaria]",
	["3,6"]  = "Chag Tvuah (Festival of Harvest) [Sylvapolis]",
	["3,18"] = "Anagenesis Eirmos (Procession of Rebirth) [Acheron]",
	["3,28"] = "Panagia Therizis (Holy Day of the Reaper) [Sylvapolis]",
	["3,37"] = "Anniversary of victory in the Morovian Frontier Campaign [Acheron]",
	["3,43"] = "Karnavali Thysias (Carnival of Celebration) [Erythros]",
	["3,53"] = "Sefar Yashar (Straight Path Celebration) [Catonis Atrium]",
}

---------------------------------------------------------
-- simulatePriceChange (same logic, but uses cached city signals)
---------------------------------------------------------
local function simulatePriceChange(basePrice, dayOfMonth, month, psscYear, dayOfYear, city, productName, companyName)
	local dateKey = string.format("%d,%d", month, dayOfMonth)

	local changeFactor = math.random(-20, 20) / 100
	local explanationParts = {}

	if events[dateKey] then
		table.insert(explanationParts, events[dateKey] .. ": Prices influenced by event dynamics")
		changeFactor = changeFactor + 0.05
	else
		table.insert(explanationParts, "General market fluctuations")
	end

	local cityAdd = 0
	local notes = {}

	city = tostring(city or "")
	if city ~= "" then
		local pClass = productClassServ(productName, companyName)

		local wx = getForecastSignal(city, psscYear, dayOfYear)
		cityAdd = cityAdd + (wx.mult or 0)
		if wx.note then table.insert(notes, wx.note) end

		local wl = getWarLeagueSignal(city, wx.opsLevel or 0, psscYear, dayOfYear)
		cityAdd = cityAdd + (wl.mult or 0)
		if wl.note then table.insert(notes, wl.note) end

		local hm = getHatchSignal(city, psscYear, dayOfYear)
		cityAdd = cityAdd + (hm.mult or 0)
		if hm.note then table.insert(notes, hm.note) end

		local ph = getHealthSignal(city)
		cityAdd = cityAdd + (ph.mult or 0)
		if ph.note then table.insert(notes, ph.note) end

		local tb = getTempleBankSignal(pClass, ph.severity or "NONE", wx.opsLevel or 0)
		cityAdd = cityAdd + (tb.mult or 0)
		if tb.note then table.insert(notes, tb.note) end
	end

	cityAdd = clamp(cityAdd, -0.20, 0.20)
	changeFactor = clamp(changeFactor + cityAdd, -0.35, 0.35)

	if #notes > 0 then
		table.insert(explanationParts, "Local signals: " .. table.concat(notes, "; "))
	end

	local explanation = table.concat(explanationParts, ". ") .. "."
	local newPrice = math.floor((basePrice * (1 + changeFactor)) * 100) / 100
	return newPrice, changeFactor, explanation
end

---------------------------------------------------------
-- determinePriceLevel
---------------------------------------------------------
local function determinePriceLevel(basePrice, adjustedPrice)
	if adjustedPrice > basePrice then
		return "Low"
	elseif adjustedPrice < basePrice then
		return "High"
	else
		return "Standard"
	end
end

---------------------------------------------------------
-- Args helpers
---------------------------------------------------------
local function getArgs(frame)
	if type(frame) ~= "table" then return {} end
	local args = {}
	local fargs = frame.args or {}
	local pargs = {}
	if frame.getParent then
		local parent = frame:getParent()
		if parent and parent.args then
			pargs = parent.args
		end
	end
	for k, v in pairs(pargs) do if v ~= nil and v ~= "" then args[k] = v end end
	for k, v in pairs(fargs) do if v ~= nil and v ~= "" then args[k] = v end end
	return args
end

local function isNo(v)
	v = tostring(v or ""):lower()
	return (v == "no" or v == "n" or v == "false" or v == "0")
end

local function levelSymbol(level)
	if level == "Low" then
		return "↑"
	elseif level == "High" then
		return "↓"
	else
		return "•"
	end
end

---------------------------------------------------------
-- generateTable (OPTIMIZED output building)
---------------------------------------------------------
function p.generateTable(frame)
	local args = getArgs(frame)
local fast = tostring(args.fast or ""):lower()
local useSignals = not (fast == "yes" or fast == "true" or fast == "1")

	local mode = tostring(args.mode or "both"):lower()
	local collapse = not isNo(args.collapse)
	local showSummary = (mode == "both" or mode == "summary")
	local showBreakdown = (mode == "both" or mode == "breakdown")

	-- Seed randomness per day
	local localTime = os.date("*t")
	local dailySeed = localTime.year * 1000 + localTime.yday
	math.randomseed(dailySeed)

	-- Date
	local dateString, dayOfMonth, month, psscYear, dayOfYear = getCurrentDate()

	-- Reset caches per invocation (avoid cross-page pollution)
	cache.forecast = {}
	cache.war = {}
	cache.warCount = {}
	cache.hatchCount = {}
	cache.health = {}
	hatchReportText = nil
	warTableText = nil

	-- Determine which unique cities we actually need (avoid scanning patterns for unused cities)
	local neededCities = {}
	for _, product in ipairs(products) do
		local _, company = product[1], product[2]
		local city = inferHQCity(company)
		if city and city ~= "" then
			neededCities[city] = true
		end
	end

	-- Warm up caches cheaply for each city (one outbreak call per city; one pattern scan per city)
	if useSignals then
	for city, _ in pairs(neededCities) do
		getForecastSignal(city, psscYear, dayOfYear)     -- cached
		getHatchCityCount(city, psscYear, dayOfYear)    -- cached (builds report once)
		getWarCityCount(city, psscYear, dayOfYear)      -- cached (builds table once)
		getHealthSignal(city)                           -- cached
	end
end

	local outParts = {}

	-- Summary header
	local summaryParts = {}
	if showSummary then
		table.insert(summaryParts, "{| class=\"wikitable sortable\"\n")
		table.insert(summaryParts, "! Date (Day/Month/Year [[PSSC]]) !! Δ !! Product !! Producing Company !! Tier I Price !! Units !! Notes\n")
	end

	-- Breakdown header
	local breakdownParts = {}
	if showBreakdown then
		local collapseClass = collapse and " mw-collapsible mw-collapsed" or ""
		table.insert(breakdownParts, "{| class=\"wikitable sortable" .. collapseClass .. "\"\n")
		table.insert(breakdownParts, "|+ Full tier breakdown" .. (collapse and " (click to expand)" or "") .. "\n")
		table.insert(breakdownParts, "! Date !! Product !! Producing Company !! Base Price !! Level !! Tier III !! Tier II !! Tier I !! Units !! Explanation\n")
	end

	local totalBase, totalNew, count = 0, 0, 0

	for _, product in ipairs(products) do
		local name, company, basePrice, units = unpack(product)
		local city = inferHQCity(company)

		local newPrice, _, explanation = simulatePriceChange(basePrice, dayOfMonth, month, psscYear, dayOfYear, city, name, company)
		local priceLevel = determinePriceLevel(basePrice, newPrice)
		local sym = levelSymbol(priceLevel)

		local rowStyle
		if priceLevel == "Low" then
			rowStyle = ' style="background-color:lightblue;"'
		elseif priceLevel == "Standard" then
			rowStyle = ' style="background-color:lightgreen;"'
		else
			rowStyle = ' style="background-color:#ffcccb;"'
		end

		local tierIIIPrice = math.floor((newPrice / 3) * 100) / 100
		local tierIIPrice  = math.floor((newPrice * 2 / 3) * 100) / 100
		local tierIPrice   = newPrice

		totalBase = totalBase + basePrice
		totalNew  = totalNew + newPrice
		count = count + 1

		if showSummary then
			table.insert(summaryParts, string.format(
				"|-%s\n| %s || %s || %s || %s || %.2f || %s || %s\n",
				rowStyle, dateString, sym, name, normalizeCompany(company), tierIPrice, units, explanation
			))
		end

		if showBreakdown then
			table.insert(breakdownParts, string.format(
				"|-%s\n| %s || %s || %s || %.2f || %s || %.2f || %.2f || %.2f || %s || %s\n",
				rowStyle, dateString, name, normalizeCompany(company), basePrice, priceLevel,
				tierIIIPrice, tierIIPrice, tierIPrice, units, explanation
			))
		end
	end

	local avgBase = totalBase / count
	local avgNew  = totalNew / count
	local avgLevel
	if avgNew > avgBase then
		avgLevel = "Low"
	elseif avgNew < avgBase then
		avgLevel = "High"
	else
		avgLevel = "Standard"
	end
	local avgSym = levelSymbol(avgLevel)

	if showSummary then
		table.insert(summaryParts, string.format(
			"|-\n! colspan=\"7\" | Average adjusted (%.2f) vs base (%.2f): %s %s\n|}\n",
			avgNew, avgBase, avgSym, avgLevel
		))
		table.insert(outParts, table.concat(summaryParts))
		table.insert(outParts, "\n")
	end

	if showBreakdown then
		table.insert(breakdownParts, string.format(
			"|-\n! colspan=\"10\" | Average adjusted (%.2f) vs base (%.2f): %s %s\n|}\n",
			avgNew, avgBase, avgSym, avgLevel
		))
		table.insert(outParts, table.concat(breakdownParts))
	end

	return table.concat(outParts)
end

function p.full(frame)
	frame = frame or {}
	frame.args = frame.args or {}
	frame.args.mode = "breakdown"
	frame.args.collapse = "no"
	return p.generateTable(frame)
end

return p