Module:Item2: Difference between revisions

From Path of Exile Wiki
Jump to navigation Jump to search
>TheFrz
m (Added support for attributes to item tables)
No edit summary
 
(392 intermediate revisions by 11 users not shown)
Line 1: Line 1:
-- SMW reworked item module
-------------------------------------------------------------------------------
--
--                                Module:Item2
--
-- This module implements Template:Item.
-------------------------------------------------------------------------------
 
require('Module:No globals')
local m_util = require('Module:Util')
local m_item_util -- Lazy load require('Module:Item util')
local m_cargo = require('Module:Cargo')


-- ----------------------------------------------------------------------------
-- Should we use the sandbox version of our submodules?
-- TODO
local use_sandbox = m_util.misc.maybe_sandbox('Item2')
-- ----------------------------------------------------------------------------
 
-- Items
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')
-- -----
 
--
-- Lazy loading
-- DROP restriction improvements:
local f_process_skill_data -- require('Module:Skill').process_skill_data
--  drop location (area)
local f_item_link -- require('Module:Item link').item_link
--  drop difficulty
local f_query_area_info -- require('Module:Area').query_area_info
--  drop monster type(s)
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
--  drop league restriction
local f_append_schema -- require('Module:Item2/cargo').append_schema
--
 
-- divination card support
-- The cfg table contains all localisable strings and configuration, to make it
--
-- easier to port this module to another wiki.
-- talismans:
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')
-- tier
--  category
--
-- unique items:
-- 3D art
--  supporter attribution
--
-- potentially include quality bonus in calculations
-- singular for weapon class in infoboxes
--
-- Maps:  
--  Area level can be retrieved eventually
-- Hallowed Ground has changed area level from mod
--
-- Essence:  
-- type column
--  monster modifier info
--
-- Weapons:
--  show DPS in infobox; hover?
--
-- ----------
-- Item table
-- ----------
-- adopt the new system for gems
-- ----------
-- Item class
-- ----------
--
-- remove the ul if name_list is not provided
-- maybe smw


local i18n = cfg.i18n


-- ----------------------------------------------------------------------------
local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')
-- Imports
-- ----------------------------------------------------------------------------
local xtable = require('Module:Table')
local util = require('Module:Util')
local getArgs = require('Module:Arguments').getArgs
local m_game = require('Module:Game')
local m_skill = require('Module:Skill')


local p = {}
-- Declare early to avoid errors
local c = {}
local c = {}
c.image_size = 39
-- 9 doesn't hit the query limit
c.max_mod_params = 11
c.max_stat_params = 8


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Other stuff
-- Helper functions
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


local h = {}
local h = {}


function h.debug(tpl_args, func)
-- Lazy loading for Module:Skill
     if tpl_args.debug ==  nil then
function h.process_skill_data(tpl_args)
         return
     if not f_process_skill_data then
         f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
     end
     end
     func()
     return f_process_skill_data(tpl_args)
end
end


function h.na_or_val(tr, value, func)
-- Lazy loading for Module:Item link
     if value == nil then
function h.item_link(args)
         tr:wikitext(util.html.td.na())
     if not f_item_link then
    else
         f_item_link = require('Module:Item link').item_link
        local raw_value = value
        if func ~= nil then
            value = func(value)
        end
        tr
            :tag('td')
                :attr('data-sort-value', raw_value)
                :wikitext(value)
                :done()
     end
     end
    return f_item_link(args)
end
end


-- helper to loop over the range variables easier
-- Lazy loading for Module:Area
h.range_map = {
function h.query_area_info(args)
    min = {
     if not f_query_area_info then
        property = ' range minimum',
        f_query_area_info = require('Module:Area').query_area_info
        var = '_range_minimum',
     end
    },
     return f_query_area_info(args)
    max = {
        property = ' range maximum',
        var = '_range_maximum',
    },
    avg = {
        property = ' range average',
        var = '_range_average',
    },
}
 
function h.handle_range_args(tpl_args, frame, argument_key, property, value, fmt_options)
     fmt_options = mw.clone(fmt_options)
    fmt_options.return_color = true
    local html, colour = h.format_value(tpl_args, frame, value, fmt_options)
    tpl_args[argument_key .. '_html'] = html
    tpl_args._properties[property .. ' HTML'] = html
     tpl_args._properties[property .. ' range colour'] = colour
      
    fmt_options = mw.clone(fmt_options)
    fmt_options.no_color = true
    tpl_args._properties[property .. ' range text'] = h.format_value(tpl_args, frame, value, fmt_options)
end
end


function h.stats_update(tpl_args, id, value, modid, key)
-- Lazy loading for Module:Item2/cargo
     if tpl_args[key][id] == nil then
function h.append_schema(tpl_args, tables)
         tpl_args[key][id] = {
     if not f_append_schema then
            references = {modid},
         f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
            min = value.min,
            max = value.max,
            avg = value.avg,
        }
    else
        if modid ~= nil then
            table.insert(tpl_args[key][id].references, modid)
        end
        tpl_args[key][id].min = tpl_args[key][id].min + value.min
        tpl_args[key][id].max = tpl_args[key][id].max + value.max
        tpl_args[key][id].avg = tpl_args[key][id].avg + value.avg
     end
     end
    return f_append_schema(tpl_args, tables)
end
end


h.stat = {}
-- Lazy loading for Module:Item2/recipes
function h.stat.add (value, stat_cached)  
function h.process_recipes(tpl_args)
     value.min = value.min + stat_cached.min
     if not f_process_recipes then
     value.max = value.max + stat_cached.max
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
     end
    return f_process_recipes(tpl_args)
end
end


function h.stat.more (value, stat_cached)
function h.handle_range_args(tpl_args, key, field, value, options)
    value.min = value.min * (1 + stat_cached.min / 100)
     local opt = {}
    value.max = value.max * (1 + stat_cached.max / 100)
     for k, v in pairs(options or {}) do
end
        opt[k] = v
 
function h.stat.more_inverse (value, stat_cached)
     value.min = value.min / (1 + stat_cached.min / 100)
    value.max = value.max / (1 + stat_cached.max / 100)
end
 
h.tbl = {}
 
function h.tbl.range_properties(property)
     return function()
        local props = {}
        for _, prop in ipairs({'average', 'text', 'colour'}) do
            props[#props+1] = string.format('Has %s range %s', property, prop)
        end
        return props
     end
     end
    local html, val2 = m_util.html.format_value(tpl_args, value, opt)
    tpl_args[key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = val2.color
    opt.color = false
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end
end


h.tbl.display = {}
h.stat = {}
function h.tbl.display.na_or_val(tr, value, data)
function h.stat.add(value, magnitude)
     return h.na_or_val(tr, value)
     value.min = value.min + magnitude.min
    value.max = value.max + magnitude.max
end
end


function h.tbl.display.seconds(tr, value, data)
function h.stat.add_distance(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     -- Stats for distance are 10x the display value
        return string.format('%ss', value)
    value.min = value.min + (magnitude.min / 10)
    end)
    value.max = value.max + (magnitude.max / 10)
end
end


function h.tbl.display.percent(tr, value, data)
function h.stat.increased(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     value.min = value.min * (1 + magnitude.min / 100)
        return string.format('%s%%', value)
    value.max = value.max * (1 + magnitude.max / 100)
    end)
end
end


function h.tbl.display.wikilink(tr, value, data)
function h.stat.increased_inverse(value, magnitude)
     return h.na_or_val(tr, value, function(value)
     value.min = value.min / (1 + magnitude.min / 100)
        return string.format('[[%s]]', value)
    value.max = value.max / (1 + magnitude.max / 100)
    end)
end
end


h.tbl.display.factory = {}
--
function h.tbl.display.factory.value(args)
-- Processing
    args.options = args.options or {}
--


    return function(tr, data, properties)
function h.process_arguments(tpl_args, params)
        values = {}
    tpl_args._processed_args = tpl_args._processed_args or {}
       
    tpl_args._base_item_args = tpl_args._base_item_args or {}
        for _, prop in ipairs(properties) do
    for _, k in ipairs(params) do
            values[#values+1] = data[prop]
        local arg_def = core.map[k]
         end
         if arg_def == nil then
          
            if tpl_args.debug then
       
                error(string.format(i18n.debug.invalid_argument_key, k))
        local td = tr:tag('td')
            end
        td:attr('data-sort-value', table.concat(values, ', '))
         else
        td:wikitext(table.concat(values, ', '))
            if arg_def.inherit ~= false then
        if args.colour then
                table.insert(tpl_args._base_item_args, k)
            td:attr('class', 'tc -' .. args.colour)
            end
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
                tpl_args._flags.uses_deprecated_parameters = true
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                table.insert(tpl_args._deprecated_args, k)
            end
            if arg_def.func ~= nil then
                tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
            end
            if tpl_args[k] == nil then
                if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
                    -- Defaults based on item class
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                elseif arg_def.default ~= nil then
                    -- General defaults
                    if type(arg_def.default) == 'function' then
                        tpl_args[k] = arg_def.default(tpl_args)
                    else
                        tpl_args[k] = arg_def.default
                    end
                end
            end
            tpl_args._processed_args[k] = true
         end
         end
     end
     end
end
end


function h.tbl.display.factory.range(args)
--
    -- args: table
-- Display
    -- property
--
    return function (tr, data, properties)
 
         tr
function h.strip_random_stats(tpl_args, stat_text)
             :tag('td')
    if tpl_args._flags.random_mods then
                :attr('data-sort-value', data[string.format('Has %s range average', args.property)] or '-1')
         repeat
                :attr('class', 'tc -' .. (data[string.format('Has %s range colour', args.property)] or 'default'))
             local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
                 :wikitext(data[string.format('Has %s range text', args.property)])
            if text ~= nil then
                :done()
                 stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
            end
        until text == nil
     end
     end
    return stat_text
end
end


function h.format_value(tpl_args, frame, value, options)
function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
     -- value: table
     local statcont = mw.html.create('span')
    --  min:
        :addClass('item-stats')
    --  max:
     local count = 0 -- Number of groups in infobox
     -- options: table
     for _, group in ipairs(mapping) do
     --  fmt: formatter to use for the value instead of valfmt
        local lines = {}
    --  fmt_range: formatter to use for the range values. Default: (%s to %s)
        for _, line in ipairs(group) do
    --  before: add this string before the coloured string with colour gray
            local show = true
    --  before_color: colour to use for the before string; false to disable
            if line.show == false then
    --  after: add this string after the coloured string with colour gray
                show = false
    --  after_color: colour to use for the after string; false to disabled-drop
            elseif type(line.show) == 'function' then
    --  func: Function to adjust the value with before output
                show = line.show(tpl_args)
    --  color: colour code for util.html.poe_color, overrides mod colour
            end
    --  no_color: set to true to ingore colour entirely
            if show then
    --  return_color: also return colour
                lines[#lines+1] = line.func(tpl_args)
 
            end
    if options.no_color == nil then
        end
        if options.color then
        if #lines > 0 then
            value.color = options.color
            count = count + 1
        elseif value.base ~= value.min or value.base ~= value.max then
            local heading = ''
             value.color = 'mod'
            if group.heading == nil then
        else
            elseif type(group.heading) == 'function' then
            value.color = 'value'
                heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
            end
             statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
         end
         end
     end
     end
   
 
     if options.func ~= nil then
    -- Add groups to infobox
         value.min = options.func(tpl_args, frame, value.min)
     if count > 0 then
        value.max = options.func(tpl_args, frame, value.max)
         infobox:node(statcont)
     end
     end
end
function h.make_main_infobox(tpl_args)
    local infobox = mw.html.create('span')
        :addClass('item-box -' .. tpl_args.frame_type)
      
      
     if options.fmt == nil then
     if tpl_args.class_id == 'DivinationCard' then
         options.fmt = '%s'
         local divcard = infobox
    elseif type(options.fmt) == 'function' then
            :tag('span')
        options.fmt = options.fmt(tpl_args, frame)
                :addClass('divicard-wrapper')
    end
         local card_background = tpl_args.card_background or {}
   
        if #card_background > 0 then
    if value.min == value.max then
            divcard
        value.out = string.format(options.fmt, value.min)
                :tag('span')
    else
                    :addClass('divicard-background')
         value.out = string.format(string.format(options.fmt_range or "(%s to %s)", options.fmt, options.fmt), value.min, value.max)
                    :wikitext(string.format(
    end
                        '[[%s|390px|gif]]',
   
                        string.format(
    if options.no_color == nil then
                            i18n.files.divination_card_background,
        value.out = util.html.poe_color(value.color, value.out)
                            table.concat(card_background, '-')
    end
                        )
   
                    ))
    local text = {
        before = '',
        after = '',
    }
   
    for var, _ in pairs(text) do
        if type(options[var]) == 'string' then
            text[var] = options[var]
        elseif type(options[var]) == 'function' then
            text[var] = options[var](tpl_args, frame)
        end
       
        if text[var] ~= '' then
            local color
            if options[var .. '_color'] == nil then
                color = 'default'
            elseif options[var .. '_color'] ~= false then
                color = options[var .. '_color']
            end
           
            if color ~= nil then
                text[var] = util.html.poe_color(color, text[var])
            end
         end
         end
        divcard
            :tag('span')
                :addClass('divicard-art')
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-frame')
                :done()
            :tag('span')
                :addClass('divicard-header')
                :wikitext(tpl_args.name)
                :done()
            :tag('span')
                :addClass('divicard-artlink')
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-stack')
                :wikitext(tpl_args.stack_size)
                :done()
            :tag('span')
                :addClass('divicard-face')
                :tag('span')
                    :addClass('divicard-reward')
                    :wikitext(tpl_args.description)
                    :done()
                :tag('span')
                    :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                    :done()
    else
        local line_type
        local name_line
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
            name_line = tpl_args.name
        end
        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        local symbols
        local influences = tpl_args.influences or {}
        if tpl_args.is_replica then
            symbols = {'replica', 'replica'}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
        elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
            symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
            symbols = {
                tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
            }
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
        end
       
        infobox
            :tag('span')
                :addClass('header -' .. line_type)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[1] or nil)
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
            :done()
           
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
     end
     end
      
      
    local return_color
     if tpl_args.skill_icon ~= nil then
     if options.return_color ~= nil then
         infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
         return_color = value.color
     end
     end
     return text.before .. value.out .. text.after, return_color
   
     return infobox
end
end


-- ----------------------------------------------------------------------------
--  
-- core
-- Factory
-- ----------------------------------------------------------------------------
--  


local core = {}
h.factory = {}


function core.validate_mod(tpl_args, frame, args)
function h.factory.maybe_show_infobox_line(args)
     -- args:
     -- Verifies that a list of keys are present in tpl_args and that the item
     -- key  - implict or explicit
     -- should use those keys. Returns true if all conditions are met, otherwise
     -- i
     -- returns false.
     --  value
     return function (tpl_args)
    local value = tpl_args[args.key .. args.i]
        local keys = args.keys or {}
    local out = {
        local conditions = args.conditions or {}
         result=nil,
         if #keys == 0 then
         modid=nil,
            return false
         type=args.key,
         end
    }
         for _, k in ipairs(keys) do
   
            if tpl_args[k] == nil then
    if value ~= nil then
                return false
        table.insert(tpl_args.mods, value)
            end
        table.insert(tpl_args[args.key .. '_mods'], value)
            local t = type(tpl_args[k])
        out.modid = value
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
        --out.result = nil
                return false
         table.insert(tpl_args._mods, out)
            end
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
                return false
            end
         end
         return true
         return true
    else
        value = tpl_args[args.key .. args.i .. '_text']
        if value ~= nil then
            --table.insert(tpl_args._subobjects, {
            --    ['Is mod number'] = args.i,
            --  ['Has mod text'] = value,
            --})
            out.result = value
            table.insert(tpl_args._mods, out)
            return true
        end
     end
     end
   
    return false
end
end


function core.process_smw_mods(tpl_args, frame)
function h.factory.display_raw_value(key)
     if #tpl_args.mods == 0 then
     return function(tpl_args)
         return
         return tpl_args[key]
     end
     end
      
end
     local mods = {}
 
     for _, mod_data in ipairs(tpl_args._mods) do
function h.factory.descriptor_value(args)
         if mod_data.result == nil then
    -- Arguments:
             mods[mod_data.modid] = mod_data
     --  key
     --  tbl
    args = args or {}
     return function (tpl_args, value)
        args.tbl = args.tbl or tpl_args
         if args.tbl[args.key] then
             value = m_util.html.abbr(value, args.tbl[args.key])
         end
         end
        return value
     end
     end
   
end
    local results = {}
 
    local result
-- ----------------------------------------------------------------------------
    local query
-- Additional configuration
    local number_of_queries = math.ceil(#tpl_args.mods / c.max_mod_params)
-- ----------------------------------------------------------------------------
    local pages = {}
 
   
-- helper to loop over the range variables easier
    for query_number=1, number_of_queries do
c.range_map = {
        local offset = (query_number-1)*c.max_mod_params
    min = '_range_minimum',
        local mod_ids = {}
    max = '_range_maximum',
        for j=(1+offset), (c.max_mod_params+offset) do
    avg = '_range_average',
            mod_ids[#mod_ids+1] = tpl_args.mods[j]
}
        end
   
        query = {
            string.format('[[Is mod::%s]]', table.concat(mod_ids, '||')),
            '?#=Page',
            '?Is mod#',
            '?Has mod group#',
            '?Has mod type#',
            '?Has stat text#',
            '?Has level requirement#',
        }
       
        result = util.smw.query(query, frame)
   
        -- remap this as table with modids as key
        for _, row in ipairs(result) do
            results[#results+1] = row
           
            local mod_data = mods[row['Is mod']]
            mod_data.result = row
           
            -- needed for the query
            pages[#pages+1] = row[1]
            -- needed for the mapping stats to mods
            pages[row[1]] = mod_data
           
            -- update item level requirement
            local keys = {'required_level_final'}
            -- only update base item requirement if this is an implicit
            if mod_data.key == 'implicit' then
                keys[#keys+1] = 'required_level'
            end
           
            for _, key in ipairs(keys) do
                local req = math.floor(tonumber(row['Has level requirement']) * 0.8)
                if req > tpl_args[key] then
                    tpl_args[key] = req
                end
            end
        end
    end
   
    -- TODO: Can items have mods twice? I dont think so, if they do it would need to be accounted for here
    if #results ~= #tpl_args.mods then
        local missing = {}
        for _, modid in ipairs(tpl_args.mods) do
            if mods[modid].result == nil then
                missing[#missing+1] = modid
            end
        end


        local duplicates = {}
--
        for _, row in ipairs(results) do
-- Contents here are meant to resemble the ingame infobox of items
            if duplicates[row['Is mod']] == nil then
--
                duplicates[row['Is mod']] = {row['Page']}
c.item_infobox_groups = {
            else
    -- [n]:
                table.insert(duplicates[row['Is mod']], row['Page'])
    --  class: Additional css class added to group tag
            end
    --  heading: Group heading text (used for extras)
        end
    --  lines:
       
    --  [n]:
        local text = {}
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
         for modid, pages in pairs(duplicates) do
    --    func: Function that returns line text
             if #pages <= 1 then
    {
                 duplicates[modid] = nil
         -- Item type (weapons, hideout decorations, abyss jewels)
             else
        {
                text[#text+1] = string.format('%s (pages: %s)', modid, table.concat(pages, ', '))
             show = function (tpl_args)
             end
                 return i18n.item_class_map[tpl_args.class_id] ~= nil
         end
             end,
          
            func = function (tpl_args)
         error(string.format('Number of mods found does not match number of queried mods. Not found: "%s", duplicates: "%s"', table.concat(missing, ', '), table.concat(text)))
                return i18n.item_class_map[tpl_args.class_id]
    end
             end,
   
         },
    -- fetch stats
         -- Cosmetic item type
   
         {
    number_of_queries = math.ceil(#pages / c.max_stat_params)
            show = h.factory.maybe_show_infobox_line{
   
                keys = {'cosmetic_type'},
    for query_number=1, number_of_queries do
                conditions = {processed = true},
        local offset = (query_number-1)*c.max_stat_params
            },
        local temp_pages = {}
            func = h.factory.display_raw_value('cosmetic_type'),
        for j=(1+offset), (c.max_stat_params+offset) do
        },
            temp_pages[#temp_pages+1] = pages[j]
        -- Gems
        end
        {
       
            show = h.factory.maybe_show_infobox_line{
        query = {
                keys = {'gem_tags'},
            string.format('[[-Has subobject::%s]] [[Has stat id::+]] [[Has minimum stat value::+]] [[Has maximum stat value::+]]', table.concat(temp_pages, '||')),
                conditions = {processed = true},
             '?Is stat number#',
            },
             '?Has stat id#',
            func = function (tpl_args)
             '?Has minimum stat value#',
                local out = {}
            '?Has maximum stat value#',
                for i, tag in ipairs(tpl_args.gem_tags) do
        }
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
       
                end
        local stats = util.smw.query(query, frame)
                return table.concat(out, ', ')
       
            end,
         -- process and cache stats
        },
         for _, stat in ipairs(stats) do
        {
             local mod_data = pages[util.string.split(stat[1], '#')[1]]
             show = h.factory.maybe_show_infobox_line{
            if mod_data.result.stats == nil then
                keys = {'support_gem_letter_html'},
                 mod_data.result.stats = {stat, }
                conditions = {processed = true},
            else
             },
                mod_data.result.stats[#mod_data.result.stats+1] = stat
             func = core.factory.infobox_line{
             end
                parts = {
       
                    {
             local id = stat['Has stat id']
                        key = 'support_gem_letter_html',
            local value = {
                        color = false,
                 min = tonumber(stat['Has minimum stat value']),
                    },
                max = tonumber(stat['Has maximum stat value']),
                },
            }
                fmt = i18n.tooltips.support_icon,
            value.avg = (value.min+value.max)/2
            },
           
         },
            h.stats_update(tpl_args, id, value, mod_data.result['Is mod'], '_stats')
         {
            if mod_data.type ~= 'implicit' then
             show = function (tpl_args)
                 h.stats_update(tpl_args, id, value, mod_data.result['Is mod'], '_explicit_stats')
                 return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
             end
             end,
         end
             func = function (tpl_args)
    end
                local value = {
end
                    base = 1,
 
                    min = 1,
function core.process_base_item(tpl_args, frame, args)
                    max = tpl_args.max_level,
    local query = {}
                 }
 
                local options = {
    if tpl_args.base_item_id ~= nil then
                    fmt = '%i',
        query[#query+1] = string.format('[[Has metadata id::%s]]', tpl_args.base_item_id)
                    color = 'value',
    elseif tpl_args.base_item_page ~= nil then
                }
        query[#query+1] = string.format('[[%s]]', tpl_args.base_item_page)
                return string.format(
    elseif tpl_args.base_item ~= nil then
                    i18n.tooltips.level,
        query[#query+1] = string.format('[[Has name::%s]]', tpl_args.base_item)
                    m_util.html.format_value(tpl_args, value, options)
    elseif tpl_args.rarity ~= 'Normal' then
                 )
        error(core.err{msg='Rarity is set to above normal, but base item is not set. A base item for rarities above normal is required!'})
             end,
    else
         },
        return
        {
    end
            show = function (tpl_args)
   
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
    if #query > 1 and tpl_args.rarity == 'Normal' then
            end,
        error(core.err{msg='Base item parameter is set, but rarity is set to normal. A rarity above normal is required!'})
            func = function (tpl_args)
    end
                local parts = {}
   
                for k, v in pairs(m_game.constants.skill.cost_types) do
    query[#query] = query[#query] .. string.format('[[Has item class::%s]] [[Has rarity::Normal]]', tpl_args['class'])
                    parts[#parts+1] = {
    query[#query+1] = '?Has implicit mod ids#'
                        key = 'cost_' .. k,
    query[#query+1] = '?Has metadata id'
                        func = function (tpl_args, value)
    query[#query+1] = '?Has name'
                            if string.find(k, 'PerMinute', 1, true) then
   
                                value = value / 60 -- Cost per second
    for _, k in ipairs(tpl_args._base_item_args) do
                            end
        if core.map[k].property ~= nil then
                            return value
            query[#query+1] = string.format('?%s#', core.map[k].property)
                        end,
        end
                        fmt = '%i',
    end
                        inline = string.format(
   
                            '%%s%s %s',
    local result = util.smw.query(query, frame)
                            string.find(k, 'Percent', 1, true) and '%%' or '',
   
                            v.long_upper
    if #result > 1 then
                        ),
        error(core.err{msg='More then one result found for the specified base item. Consider using base_item_page or base_item_id to narrow down the results.'})
                     }
        -- TODO be more explicit in the error?
    end
   
    result = result[1]
   
    tpl_args.base_item_data = result
    core.process_arguments(tpl_args, frame, {array={'base_item', 'base_item_page', 'base_item_id'}})
 
    --Copy values..
    for _, k in ipairs(tpl_args._base_item_args) do
        local data = core.map[k]
        if data.property then
            local value = result[data.property]
            -- I can just use data.default since it will be nil if not provided. Neat! ;)
            if value ~= "" and tpl_args[k] == data.default then
                tpl_args[k] = value
                if data.property_func ~= nil then
                    data.property_func(tpl_args, frame)
                elseif data.func ~= nil then
                     data.func(tpl_args, frame)
                 end
                 end
            elseif value == "" then
                return core.factory.infobox_line{
                h.debug(tpl_args, function ()
                    type = 'gem',
                     mw.logObject(string.format("Base item property not found: %s", data.property))
                    parts = parts,
                 end)
                    sep = ', ',
             elseif tpl_args[k] ~= data.default then
                     fmt = i18n.tooltips.cost,
                h.debug(tpl_args, function ()
                 }(tpl_args)
                    mw.logObject(string.format("Value for arg '%s' is set to something else then default: %s", k, tostring(tpl_args[k])))
             end,
                end)
        },
             end
        {
        elseif data.property_func ~= nil then
            show = function (tpl_args)
             -- property func is set, but not a property. Probably fetching subobjects here
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            data.property_func(tpl_args, frame)
             end,
        end
             func = core.factory.infobox_line{
    end
                type = 'gem',
end
                parts = {
 
                    {
function core.process_arguments(tpl_args, frame, args)
                        key = 'mana_reservation_flat',
    for _, k in ipairs(args.array) do
                        fmt = '%i',
        local data = core.map[k]
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
        table.insert(tpl_args._total_args, k)
                    },
        if data.no_copy == nil then
                    {
            table.insert(tpl_args._base_item_args, k)
                        key = 'mana_reservation_percent',
        end
                        fmt = '%i',
        if data.func ~= nil then
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
            data.func(tpl_args, frame)
                    },
            --[[local status, err = pcall(data.func)
                    {
            -- an error was raised, return the error string instead of the template
                        key = 'life_reservation_flat',
            if not status then
                        fmt = '%i',
                return err
                        inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
            end
                    },
            ]]--
                    {
        end
                        key = 'life_reservation_percent',
        if data.default ~= nil and tpl_args[k] == nil then
                        fmt = '%i',
            tpl_args[k] = data.default
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
         end
                    },
    end
                },
end
                sep = ', ',
          
                fmt = i18n.tooltips.reservation,
function core.process_mod_stats(tpl_args, args)
            },
    local lines = {}
         },
   
         {
    local skip = core.class_specifics[tpl_args.class]
            show = true, -- TODO: Show only if has cost_multiplier
    if skip then
            func = core.factory.infobox_line{
        skip = skip.skip_stat_lines
                type = 'gem',
    end
                parts = {
   
                    {
    for _, modinfo in ipairs(tpl_args._mods) do
                        key = 'cost_multiplier',
        if modinfo.type == args.type then
                        hide_default = 100,
             if modinfo.modid == nil then
                        fmt = '%i',
                table.insert(lines, modinfo.result)
                        inline = '%s%%',
             else
                    },
                for _, line in ipairs(util.string.split(modinfo.result['Has stat text'], '<br>')) do
                },
                    if line ~= '' then
                fmt = i18n.tooltips.cost_multiplier,
                         if skip == nil then
            },
                            table.insert(lines, line)
        },
                         else
        {
                            local skipped = false
             show = true, -- TODO: Show only if has cooldown
                            for _, pattern in ipairs(skip) do
             func = core.factory.infobox_line{
                                if string.match(line, pattern) then
                type = 'gem',
                                    skipped = true
                parts = {
                                    break
                    {
                                end
                         key = 'cooldown',
                            end
                         hide_default = 0,
                            if not skipped then
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                                table.insert(lines, line)
                    },
                            end
                },
                        end
                fmt = i18n.tooltips.cooldown_time,
                    end
            },
                end
        },
             end
        {
        end
             -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
    end
            show = true,
   
            func = core.factory.infobox_line{
    if #lines == 0 then
                type = 'gem',
        return
                parts = {
    else
                    {
        return table.concat(lines, '<br>')
                        key = 'stored_uses',
    end
                        hide_default = 0,
end
                        fmt = '%i',
 
                    },
function core.err(args)
                },
    local err = mw.html.create('div')
                fmt = i18n.tooltips.stored_uses,
    err
            },
        :attr('style', 'font-color: red; font-weight: bold;')
        },
        :wikitext(args.msg or ('Argument ' .. args.key .. ' to item template is invalid. Please check the documention for acceptable values.'))
        {
        :done()
            show = true, -- TODO: Show only if has vaal_souls_requirement
       
            func = core.factory.infobox_line{
    return tostring(err)
                type = 'gem',
end
                parts = {
 
                    {
--
                        key = 'vaal_souls_requirement',
-- function factory
                        hide_default = 0,
--
                        fmt = '%i',
core.factory = {}
                    },
function core.factory.array_table_cast(k, args)
                },
    -- Arguments:
                fmt = i18n.tooltips.vaal_souls_per_use,
    --
            },
    -- tbl
        },
    -- errmsg
        {
    return function (tpl_args, frame)
            show = true, -- TODO: Show only if has vaal_stored_uses
        local elements
            func = core.factory.infobox_line{
       
                type = 'gem',
        if tpl_args[k] ~= nil then
                parts = {
            elements = util.string.split(tpl_args[k], ', ')
                    {
             for _, element in ipairs(elements) do
                        key = 'vaal_stored_uses',
                local r = util.table.find_in_nested_array{value=element, tbl=args.tbl, key='full'}
                        hide_default = 0,
                 if r == nil then
                        fmt = '%i',
                     error(core.err{msg=string.format(args.errmsg, element)})
                    },
                end
                },
            end
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
            tpl_args[k] = xtable:new(elements)
             },
        end
        },
    end
        {
end
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
 
            func = core.factory.infobox_line{
function core.factory.table_cast(k, args)
                type = 'gem',
    return function (tpl_args, frame)
                 parts = {
         args.value = tpl_args[k]
                     {
        tpl_args[k] = util.table.find_in_nested_array(args)
                        key = 'vaal_soul_gain_prevention_time',
        if tpl_args[k] == nil then
                        hide_default = 0,
            error(core.err{key=k})
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data,
        end
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
    end
                    },
end
                },
 
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
 
            },
function core.factory.number_cast(k)
         },
    return function (tpl_args, frame)
        {
        tpl_args[k] = tonumber(tpl_args[k])
            show = function (tpl_args)
    end
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
end
            end,
 
            func = function (tpl_args)
function core.factory.boolean_cast(k)
                return core.factory.infobox_line{
    return function(tpl_args, frame)
                    parts = {
        if tpl_args[k] ~= nil then
                        {
            tpl_args[k] = util.cast.boolean(tpl_args[k])
                            key = 'cast_time',
        end
                            fmt = function (tpl_args, value)
    end
                                if value.min == 0 then
end
                                    return i18n.tooltips.instant_cast_time
 
                                end
function core.factory.percentage(k)
                                return '%.2f ' .. m_game.units.seconds.short_lower
    return function (tpl_args, frame)
                            end,
        local v = tonumber(tpl_args[k])
                        },
       
                    },
        if v == nil then
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
            return core.err{key=k}
                }(tpl_args)
        end
            end,
       
        },
        if v < 0 or v > 100 then
        {
            return core.err{msg=k .. ' must be in range 0-100.'}
            show = true, -- TODO: Show only if has attack_time
         end
            func = core.factory.infobox_line{
          
                type = 'gem',
        tpl_args[k] = v
                parts = {
    end
                    {
end
                        key = 'attack_time',
 
                        hide_default = 0,
function core.factory.display_value(args)
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
    -- TODO: sane defaults for the prepend string "before" & after arguments
                    },
    --
                },
    -- args:
                fmt = i18n.tooltips.attack_time,
    --  type: Type of the keys (nil = regular, gem = skill gems, stat = stats)
            },
    --  options<Array>:
         },
    --  key: key to use
         {
    --  allow_zero: allow zero values
            show = true, -- TODO: Show only if has critical_strike_chance
    --  hide_default: hide the value if this is set
            func = core.factory.infobox_line{
    --  hide_default_key: key to use if it isn't equal to the key parameter
                type = 'gem',
    --  -- from h.format_value --
                parts = {
    --   fmt: formatter to use for the value instead of valfmt
                    {
    --  fmt_range: formatter to use for the range values. Default: (%s to %s)
                        key = 'critical_strike_chance',
    --  before: add this string before the coloured string with colour gray
                        hide_default = 0,
    --  after: add this string after the coloured string with colour gray
                        fmt = '%.2f%%',
    --  func: Function to adjust the value with before output
                    },
    --  color: colour code for util.html.poe_color, overrides mod colour
                },
    --  no_color: set to true to ingore colour entirely
                fmt = i18n.tooltips.critical_strike_chance,
   
            },
    for k, default in pairs({options = {}}) do
        },
        if args[k] == nil then
        {
             args[k] = default
            show = true, -- TODO: Show only if has attack_speed_multiplier
        end
            func = core.factory.infobox_line{
    end
                type = 'gem',
   
                parts = {
    return function (tpl_args, frame)
                    {
         local base_values = {}
                        key = 'attack_speed_multiplier',
         local temp_values = {}
                        hide_default = 100,
        if args.type == 'gem' then
                        fmt = '%i',
             if not core.class_groups.gems.keys[tpl_args.class] then
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                 return
                    },
            end
                },
            for i, data in ipairs(args.options) do
                fmt = i18n.tooltips.attack_speed_multiplier,
                local value = tpl_args['static_' .. data.key]
             },
                if value ~= nil then
         },
                    base_values[#base_values+1] = value
         {
                    temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
            show = true, -- TODO: Show only if has damage_multiplier
                 else
             func = core.factory.infobox_line{
                    value = {
                 type = 'gem',
                        min=tpl_args[string.format('level1_%s', data.key)],
                parts = {
                        max=tpl_args[string.format('level%s_%s', tpl_args.max_level, data.key)],  
                    {
                    }
                        key = 'damage_multiplier',
                    if value.min == nil or value.max == nil then
                        hide_default = 100,
                     else
                        fmt = '%i',
                         base_values[#base_values+1] = value.min
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                         temp_values[#temp_values+1] = {value=value, index=i}
                    },
                     end
                },
                 end
                 fmt = i18n.tooltips.damage_multiplier,
             end
            },
         elseif args.type == 'stat' then
        },
             for i, data in ipairs(args.options) do
        {
                local value = tpl_args._stats[data.key]
            show = true, -- TODO: Show only if has damage_effectiveness
                 if value ~= nil then
            func = core.factory.infobox_line{
                     base_values[i] = value.min
                type = 'gem',
                     temp_values[#temp_values+1] = {value=value, index=i}
                parts = {
                 end
                     {
             end
                         key = 'damage_effectiveness',
         else
                         hide_default = 100,
             for i, data in ipairs(args.options) do
                        fmt = '%i',
                base_values[i] = tpl_args[data.key]
                        inline = '%s%%',
                 local value = {}
                     },
                if tpl_args[data.key .. '_range_minimum'] ~= nil then
                 },
                     value.min = tpl_args[data.key .. '_range_minimum']
                fmt = i18n.tooltips.damage_effectiveness,
                    value.max = tpl_args[data.key .. '_range_maximum']
             },
                elseif tpl_args[data.key] ~= nil then
        },
                    value.min = tpl_args[data.key]
         {
                    value.max = tpl_args[data.key]
            show = h.factory.maybe_show_infobox_line{
                end
                keys = {'projectile_speed'},
                if value.min == nil then
             },
                else
            func = core.factory.infobox_line{
                    temp_values[#temp_values+1] = {value=value, index=i}
                 parts = {
                 end
                     {
            end
                        key = 'projectile_speed',
        end
                     },
       
                },
         local final_values = {}
                 fmt = i18n.tooltips.projectile_speed,
         for i, data in ipairs(temp_values) do
             },
             local opt = args.options[data.index]
         },
            local insert = false
        {
            if opt.hide_default == nil then
             show = h.factory.maybe_show_infobox_line{
                insert = true
                 keys = {'radius'},
             elseif opt.hide_default_key == nil then
            },
                 local v = data.value
            func = core.factory.infobox_line{
                if opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                parts = {
                    insert = true
                     {
                end
                        key = 'radius',
            else
                        func = h.factory.descriptor_value{key='radius_description'},
                local v = {
                    },
                    min = tpl_args[opt.hide_default_key .. '_range_minimum'],
                    {
                     max = tpl_args[opt.hide_default_key .. '_range_maximum'],
                        key = 'radius_secondary',
                 }
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                 if v.min == nil or v.max == nil then
                    },
                    if opt.hide_default ~= tpl_args[opt.hide_default_key] then
                    {
                        insert = true
                        key = 'radius_tertiary',
                    end
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                elseif opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                    },
                    insert = true
                 },
                end
                sep = ' / ',
             end
                fmt = i18n.tooltips.aoe_radius,
           
            },
            if insert == true then
         },
                 table.insert(final_values, data)
         -- Quality is before item stats, but after gem stuff and item class
            end
        {
        end
             show = h.factory.maybe_show_infobox_line{
       
                keys = {'quality'},
        -- all zeros = dont display and return early
                conditions = {processed = true},
        if #final_values == 0 then
            },
             return nil
             func = core.factory.infobox_line{
         end
                 parts = {
          
                    {
        local out = {}
                        key = 'quality',
       
                        fmt = '+%i%%',
        if args.before then
                        color = 'mod',
             out[#out+1] = util.html.poe_color('default', args.before)
                        hide_default = 0,
        end
                     },
       
                 },
        for i, data in ipairs(final_values) do
                 fmt = i18n.tooltips.quality,
            local value = data.value
            },
            value.base = base_values[data.index]
        },
           
        -- Weapons
            local options = args.options[data.index]
        {
           
            show = h.factory.maybe_show_infobox_line{
            if options.color == nil and args.type == 'gem' then
                keys = {'physical_damage_html'},
                 value.color = 'value'
                conditions = {processed = true},
            end
            },
           
             func = core.factory.infobox_line{
            out[#out+1] = h.format_value(tpl_args, frame, value, options)
                 parts = {
        end
                    {
          
                        key = 'physical_damage_html',
         if args.after then
                        color = false, -- html already has color
             out[#out+1] = util.html.poe_color('default', args.after)
                    },
        end
                },
       
                fmt = i18n.tooltips.physical_damage,
        return table.concat(out, '')
             },     
    end
         },
end
         {
 
            show = true, -- Elemental Damage
function core.factory.display_value_only(key)
             func = function (tpl_args)
    return function(tpl_args, frame)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
        return tpl_args[key]
                local elements = {}
    end
                for _, key in ipairs(keys) do
end
                    if tpl_args[key] then
 
                        elements[#elements+1] = tpl_args[key]
function core.factory.descriptor_value(args)
                    end
    -- Arguments:
                end
    --  key
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
    --  tbl
                 if text ~= '' then
    args = args or {}
                    return string.format(i18n.tooltips.elemental_damage, text)
    return function (tpl_args, frame, value)
                end
        args.tbl = args.tbl or tpl_args
                return
        if args.tbl[args.key] then
            end,     
            value = util.html.abbr(value, args.tbl[args.key])
         },
        end
         {
        return value
             show = h.factory.maybe_show_infobox_line{
    end
                keys = {'chaos_damage_html'},
end
                conditions = {processed = true},
 
            },
function core.factory.damage_html(args)
            func = core.factory.infobox_line{
    return function(tpl_args, frame)
                parts = {
         if args.key ~= 'physical' then
                    {
          args.color = args.key
                        key = 'chaos_damage_html',
          args.no_color = true
                        color = false, -- html already has color
        end
                    },
        local keys = {
                },
            min=args.key .. '_damage_min',
                fmt = i18n.tooltips.chaos_damage,
             max=args.key .. '_damage_max',
            },     
        }
        },
        local value = {}
        {
       
            show = h.factory.maybe_show_infobox_line{
        for ktype, key in pairs(keys) do
                keys = {'critical_strike_chance_html'},
            value[ktype] = core.factory.display_value{options={ [1] = {
            },
                key = key,
            func = core.factory.infobox_line{
                 no_color = args.no_color,
                parts = {
                 hide_default = 0
                    {
             }}}(tpl_args, frame)
                        key = 'critical_strike_chance_html',
         end
                        color = false, -- html already has color
          
                    },
        if value.min and value.max then
                },
             value = value.min .. '&ndash;' .. value.max
                fmt = i18n.tooltips.critical_strike_chance,
            if args.color ~= nil then
            },
                value = util.html.poe_color(args.color, value)
        },
            end
         {
            tpl_args[args.key .. '_damage_html'] = value
            show = h.factory.maybe_show_infobox_line{
        end
                keys = {'attack_speed_html'},
    end
             },
end
            func = core.factory.infobox_line{
 
                parts = {
function core.factory.copy_stats(args)
                    {
    return function(tpl_args, frame)
                        key = 'attack_speed_html',
        if tpl_args._stats[args.stat_key] then
                        color = false, -- html already has color
            if tpl_args._stats[args.stat_key].min ~= tpl_args._stats[args.stat_key].max then
                    },
                error('TODO: Missing support for range item limits')
                 },
            end
                 fmt = i18n.tooltips.attacks_per_second,
            tpl_args[args.key] = tpl_args._stats[args.stat_key].min
             },
        end
         },
    end
         {
end
             show = function (tpl_args)
 
                -- Do not show for ranged weapons
--
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
-- argument mapping
                    return false
--
-- format:
-- tpl_args key = {
--  no_copy = true or nil          -- When loading an base item, dont copy this key
--  property = 'prop',              -- Property associated with this key
--  property_func = function or nil -- Function to unpack the property into a native lua value.
--                                      If not specified, func is used.
--                                      If neither is specified, value is copied as string
--  func = function or nil          -- Function to unpack the argument into a native lua value and validate it.
--                                      If not specified, value will not be set.
--  default = object                -- Default value if the parameter is nil
-- }
core.map = {
    -- special params
    html = {
        no_copy = true,
        property = 'Has infobox HTML',
        func = nil,
    },
    implicit_stat_text = {
        property = 'Has implicit stat text',
        func = function(tpl_args, frame)
            tpl_args.implicit_stat_text = core.process_mod_stats(tpl_args, {type='implicit'})
        end,
    },
    explicit_stat_text = {
        property = 'Has explicit stat text',
        func = function(tpl_args, frame)
            tpl_args.explicit_stat_text = core.process_mod_stats(tpl_args, {type='explicit'})
           
            if tpl_args.is_talisman or tpl_args.is_corrupted then
                if tpl_args.explicit_stat_text == nil or tpl_args.explicit_stat_text == '' then
                    tpl_args.explicit_stat_text = util.html.poe_color('corrupted', 'Corrupted')
                else
                    tpl_args.explicit_stat_text = (tpl_args.explicit_stat_text or '') .. '<br>' .. util.html.poe_color('corrupted', 'Corrupted')
                 end
                 end
            end
                return h.factory.maybe_show_infobox_line{
        end,
                    keys = {'weapon_range_html'},
    },
                }(tpl_args)
    stat_text = {
             end,
        property = 'Has stat text',
             func = core.factory.infobox_line{
        func = function(tpl_args, frame)
                 parts = {
             local sep = ''
                    {
             if tpl_args.implicit_stat_text and tpl_args.explicit_stat_text then
                        key = 'weapon_range_html',
                 sep = string.format('<span class="item-stat-separator -%s"></span>', tpl_args.frame_type)
                        color = false, -- html already has color
            end
                        inline = '%s ' .. m_game.units.metres.long_lower,
            local text = (tpl_args.implicit_stat_text or '') .. sep .. (tpl_args.explicit_stat_text or '')
                    },
           
                },
            if string.len(text) > 0 then
                 fmt = i18n.tooltips.weapon_range,
                 tpl_args.stat_text = text
             },
             end
         },
         end,
        -- Maps
    },
        {
    -- generic
            show = h.factory.maybe_show_infobox_line{
    class = {
                keys = {'map_area_level'},
        no_copy = true,
                conditions = {processed = true},
        property = 'Has item class',
            },
        func = core.factory.table_cast('class', {key='full', tbl=m_game.constants.item.class}),
            func = core.factory.infobox_line{
    },
                parts = {
    rarity = {
                    {
        no_copy = true,
                        key = 'map_area_level',
        property = 'Has rarity',
                        fmt = '%i',
        func = core.factory.table_cast('rarity', {key={'full', 'long_lower'}, tbl=m_game.constants.item.rarity, rtrkey='full'}),
                    },
    },
                },
    name = {
                fmt = i18n.tooltips.map_level,
        no_copy = true,
            },
        property = 'Has name',
        },
        func = nil,
        {
    },
            show = h.factory.maybe_show_infobox_line{
    size_x = {
                keys = {'map_tier'},
        property = 'Has inventory width',
                conditions = {processed = true},
        func = core.factory.number_cast('size_x'),
            },
    },
            func = core.factory.infobox_line{
    size_y = {
                parts = {
        property = 'Has inventory height',
                    {
        func = core.factory.number_cast('size_y'),
                        key = 'map_tier',
    },
                        fmt = '%i',
    drop_enabled = {
                    },
         property = 'Is drop enabled',
                },
        func = core.factory.boolean_cast('drop_enabled'),
                fmt = i18n.tooltips.map_tier,
        default = true,
            },
    },
         },
    drop_level = {
        {
        no_copy = true,
            show = function (tpl_args)
         property = 'Has drop level',
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
        func = core.factory.number_cast('drop_level'),
            end,
    },
            func = core.factory.infobox_line{
    drop_level_maximum = {
                parts = {
        no_copy = true,
                    {
        property = 'Has maximum drop level',
                        key = 'map_guild_character',
        func = core.factory.number_cast('drop_level_maximum'),
                    },
    },
                },
    required_level = {
                fmt = i18n.tooltips.map_guild_character,
        property = 'Has base level requirement',
            },
        func = core.factory.number_cast('required_level'),
         },
        default = 1,
        {
    },
            show = function (tpl_args)
    required_level_final = {
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
        property = 'Has level requirement',
            end,
        func = function(tpl_args, frame)
            func = core.factory.infobox_line{
            tpl_args.required_level_final = tpl_args.required_level
                parts = {
        end,
                    {
        default = 1,
                        key = 'unique_map_guild_character',
    },
                    },
    required_dexterity = {
                },
        property = 'Has base dexterity requirement',
                fmt = i18n.tooltips.map_guild_character,
        func = core.factory.number_cast('required_dexterity'),
            },
        default = 0,
        },
    },
        {
    required_strength = {
            show = function (tpl_args)
        property = 'Has base strength requirement',
                return tpl_args.class_id == 'Map'
        func = core.factory.number_cast('required_strength'),
            end,
        default = 0,
            func = core.factory.infobox_line{
    },
                type = 'stat',
    required_intelligence = {
                parts = {
        property = 'Has base intelligence requirement',
                    {
        func = core.factory.number_cast('required_intelligence'),
                        key = 'map_item_drop_quantity_+%',
        default = 0,
                        fmt = '%i',
    },
                        color = 'mod',
    inventory_icon = {
                        inline = '+%s%%',
        no_copy = true,
                        hide_default = 0,
         property = 'Has inventory icon',
                    },
         func = function(tpl_args, frame)
                },
            tpl_args.inventory_icon_id = tpl_args.inventory_icon or tpl_args.name
                fmt = i18n.tooltips.item_quantity,
            tpl_args.inventory_icon = string.format('File:%s inventory icon.png', tpl_args.inventory_icon_id)
            },
        end,
         },
    },
         {
    -- note: this must be called after inventory item to work correctly as it depends on tpl_args.inventory_icon_id being set
            show = function (tpl_args)
    alternate_art_inventory_icons = {
                return tpl_args.class_id == 'Map'
        no_copy = true,
            end,
        property = 'Has alternate inventory icons',
            func = core.factory.infobox_line{
        func = function(tpl_args, frame)
                type = 'stat',
            local icons = {}
                parts = {
            if tpl_args.alternate_art_inventory_icons ~= nil then
                    {
                 local names = util.string.split(tpl_args.alternate_art_inventory_icons, ', ')
                        key = 'map_item_drop_rarity_+%',
               
                        fmt = '%i',
                for _, name in ipairs(names) do
                        color = 'mod',
                    icons[#icons+1] = string.format('File:%s %s inventory icon.png', tpl_args.inventory_icon_id, name)
                        inline = '+%s%%',
                end
                        hide_default = 0,
             end
                    },
             tpl_args.alternate_art_inventory_icons = icons
                 },
        end,
                fmt = i18n.tooltips.item_rarity,
        default = {},
            },
    },
        },
    buff_icon = {
        {
        property = 'Has buff icon',
            show = function (tpl_args)
        func = function(tpl_args, frame)
                return tpl_args.class_id == 'Map'
            tpl_args.buff_icon = string.format('File:%s status icon.png', tpl_args.name)
             end,
        end,
             func = core.factory.infobox_line{
    },
                type = 'stat',
    help_text = {
                parts = {
        property = 'Has help text',
                    {
        func = nil,
                        key = 'map_pack_size_+%',
    },
                        fmt = '%i',
    flavour_text = {
                        color = 'mod',
        no_copy = true,
                        inline = '+%s%%',
        property = 'Has flavour text',
                        hide_default = 0,
        func = nil,
                    },
    },
                },
    tags = {
                fmt = i18n.tooltips.monster_pack_size,
        property = 'Has tags',
            },
        property_func = function(tpl_args, frame)
        },
            tpl_args.tags = util.string.split(tpl_args.tags, '<MANY>')
        -- Jewels
         end,
        {
         func = core.factory.array_table_cast('tags', {
            show = h.factory.maybe_show_infobox_line{
            tbl = m_game.constants.tags,
                keys = {'jewel_limit'},
            errmsg = '%s is not a valid tag',
                conditions = {processed = true},
        }),
            },
    },
            func = core.factory.infobox_line{
    metadata_id = {
                parts = {
        no_copy = true,
                    {
        property = 'Has metadata id',
                        key = 'jewel_limit',
        func = nil,
                    },
    },
                },
    is_corrupted = {
                fmt = i18n.tooltips.limited_to,
        no_copy = true,
            },
         property = 'Is corrupted',
         },
         func = core.factory.boolean_cast('is_corrupted'),  
         {
        default = false,
            show = h.factory.maybe_show_infobox_line{
    },
                keys = {'jewel_radius_html'},
    --
                conditions = {processed = true},
    -- specific section
            },
    --
            func = core.factory.infobox_line{
    -- amulets
                parts = {
    is_talisman = {
                    {
        property = 'Is talisman',
                        key = 'jewel_radius_html',
        func = core.factory.boolean_cast('is_talisman'),
                        color = false, -- html already has color
    },
                    },
   
                },
    -- flasks
                fmt = i18n.tooltips.radius,
    charges_max = {
            },
        property = 'Has base maximum flask charges',
         },
        func = core.factory.number_cast('charges_max'),
         -- Flasks
    },
        {
    charges_per_use = {
            show = h.factory.maybe_show_infobox_line{
        property = 'Has base flask charges per use',
                keys = {'flask_mana_html', 'flask_duration_html'},
        func = core.factory.number_cast('charges_per_use'),
            },
    },
            --func = core.factory.display_flask('flask_mana'),
    flask_mana = {
            func = core.factory.infobox_line{
        property = 'Has base flask mana recovery',
                parts = {
        func = core.factory.number_cast('flask_mana'),
                    {
    },
                        key = 'flask_mana_html',
    flask_life = {
                        color = false, -- html already has color
        property = 'Has base flask life recovery',
                    },
        func = core.factory.number_cast('flask_life'),
                    {
    },
                        key = 'flask_duration_html',
    flask_duration = {
                        color = false, -- html already has color
        property = 'Has base flask duration',
                    },
        func = core.factory.number_cast('flask_duration'),
                },
    },
                fmt = i18n.tooltips.flask_mana_recovery,
    buff_id = {
            },
        property = 'Has buff id',
        },
        func = nil,
        {
    },
            show = h.factory.maybe_show_infobox_line{
    buff_values = {
                keys = {'flask_life_html', 'flask_duration_html'},
        property = nil,
            },
        property_func = function(tpl_args, frame)
            func = core.factory.infobox_line{
            local results = util.smw.query({
                parts = {
                string.format('[[-Has subobject::%s]] [[Is number::+]] [[Has buff value::+]]', tpl_args.base_item_page),
                    {
                '?Is number#',
                        key = 'flask_life_html',
                '?Has buff value#',
                        color = false, -- html already has color
            }, frame)
                    },
            local values = {}
                    {
            for _, row in ipairs(results) do
                        key = 'flask_duration_html',
                local i = tonumber(row['Is number'])
                        color = false, -- html already has color
                local value = tonumber(row['Has buff value'])
                    },
                values[i] = value
                },
                if i ~= nil then
                fmt = i18n.tooltips.flask_life_recovery,
                    local key = 'buff_value' .. i
            },
                    tpl_args[key] = value
        },
                    tpl_args._subobjects[key] = {
        {
                        ['Is number'] = i,
            -- don't display for mana/life flasks
                        ['Has buff value'] = value,
            show = function (tpl_args)
                    }
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                end
                     if tpl_args[k] ~= nil then
            end
                         return false
           
            tpl_args.buff_values = values
        end,
        func = function(tpl_args, frame)
            local values = {}
            local i = 0
            local value
            local key
            repeat
                i = i + 1
                key = 'buff_value' .. i
                value = tonumber(tpl_args[key])
                values[i] = value
                tpl_args[key] = value
                tpl_args._subobjects[key] = {
                    ['Is number'] = i,
                    ['Has buff value'] = value,
                }
            until values[i] == nil
           
            tpl_args.buff_values = values
        end,
    },
    buff_stat_text = {
        property = 'Has buff stat text',
        func = nil,
    },
   
    -- weapons & active skills
    critical_strike_chance = {
        property = 'Has base critical strike chance',
        func = core.factory.number_cast('critical_strike_chance'),
    },
    -- weapons
    attack_speed = {
        property = 'Has base attack speed',
        func = core.factory.number_cast('attack_speed'),
    },
    physical_damage_min = {
        property = 'Has base minimum physical damage',
        func = core.factory.number_cast('physical_damage_min'),
    },
    physical_damage_max = {
        property = 'Has base maximum physical damage',
        func = core.factory.number_cast('physical_damage_max'),
    },
    range = {
        property = 'Has base weapon range',
        func = core.factory.number_cast('range'),
    },
    -- armor-type stuff
    armour = {
        property = 'Has base armour',
        func = core.factory.number_cast('armour'),
        default = 0,
    },
    energy_shield = {
        property = 'Has base energy shield',
        func = core.factory.number_cast('energy_shield'),
        default = 0,
    },
    evasion = {
        property = 'Has base evasion',
        func = core.factory.number_cast('evasion'),
        default = 0,
    },
    -- shields
    block = {
        property = 'Has base block',
        func = core.factory.number_cast('block'),
    },
    -- skill gem stuff
    gem_description = {
        property = 'Has description',
        func = nil,
    },
    dexterity_percent = {
        property = 'Has dexterity percentage',
        func = core.factory.percentage('dexterity_percent'),
    },
    strength_percent = {
        property = 'Has strength percentage',
        func = core.factory.percentage('strength_percent'),
    },
    intelligence_percent = {
        property = 'Has intelligence percentage',
        func = core.factory.percentage('intelligence_percent'),
    },
    primary_attribute = {
        property = 'Has primary attribute',
        func = function(tpl_args, frame)
            for _, attr in ipairs(m_game.constants.attributes) do
                local val = tpl_args[attr.long_lower .. '_percent']
                if val and val >= 60 then
                    tpl_args['primary_attribute'] = attr.long_upper
                    return
                end
            end
            tpl_args['primary_attribute'] = 'None'
        end,
    },
    gem_tags = {
        property = 'Has gem tags',
        -- TODO: default rework
        func = core.factory.array_table_cast('gem_tags', {
            tbl = m_game.constants.item.gem_tags,
            errmsg = '%s is not a valid tag',
        }),
        default = {},
    },
    experience = {
        property = 'Has maximum experience',
        func = core.factory.percentage('experience'),
    },
    skill_screenshot = {
        property = 'Has skill screenshot',
        func = function(tpl_args, frame)
            tpl_args.skill_screenshot = string.format('File:%s skill screenshot.jpg', tpl_args.name)
        end,
    },
    -- Active gems only
    gem_icon = {
        property = 'Has skill gem icon',
        func = function(tpl_args, frame)
            -- TODO readd support if needed.
            tpl_args.gem_icon = string.format('File:%s skill icon.png', tpl_args.name)
        end,
    },
    -- Support gems only
    support_gem_letter_html = {
        property = 'Has support gem letter HTML',
        func = function(tpl_args, frame)
            if tpl_args.support_gem_letter == nil then
                return
            end
       
            -- TODO replace this with a loop possibly
            local css_map = {
                strength = 'red',
                intelligence = 'blue',
                dexterity = 'green',
            }
            local id
            for k, v in pairs(css_map) do
                k = string.format('%s_percent', k)
                if tpl_args[k] and tpl_args[k] > 50 then
                    id = v
                    break
                end
            end
           
            if id ~= nil then
                local container = mw.html.create('span')
                container
                    :attr('class', string.format('support-gem-id-%s', id))
                    :wikitext(tpl_args.support_gem_letter)
                    :done()
                tpl_args.support_gem_letter_html = tostring(container)
            end
        end,
    },
    -- Maps
    map_tier = {
        property = 'Has map tier',
        func = core.factory.number_cast('tier'),
    },
    map_guild_character = {
        no_copy = true,
        property = 'Has map guild character',
        func = nil,
    },
    map_area_id = {
        no_copy = true,
        property = 'Has map area id',
        func = nil, -- TODO: Validate against a query?
    },
    map_area_level = {
        no_copy = true,
        property = 'Has map area level',
        func = core.factory.number_cast('map_area_level'),
    },
    unique_map_guild_character = {
        property = 'Has unique map guild character',
        property_func = function(tpl_args, frame)
            tpl_args.map_guild_character = tpl_args.unique_map_guild_character
            tpl_args.unique_map_guild_character = nil
        end,
        func = nil,
    },
    unique_map_area_id = {
        property = 'Has unique map area id',
        func = nil, -- TODO: Validate against a query?
        property_func = function(tpl_args, frame)
            tpl_args.map_area_id = tpl_args.unique_map_area_id
            tpl_args.unique_map_area_id = nil
        end,
    },
    unique_map_area_level = {
        property = 'Has unique map area level',
        func = core.factory.number_cast('unique_map_area_level'),
        property_func = function(tpl_args, frame)
            tpl_args.map_area_level = tpl_args.unique_map_area_level
            tpl_args.unique_map_area_level = nil
        end,
    },
    --
    -- Currency-like items
    --
    stack_size = {
        property = 'Has stack size',
        func = core.factory.number_cast('stack_size'),
    },
    stack_size_currency_tab = {
        property = 'Has currency tab stack size',
        func = core.factory.number_cast('stack_size_currency_tab'),
    },
    description = {
        property = 'Has description',
        func = nil,
    },
    cosmetic_type = {
        property = 'Has cosmetic type',
        func = nil,
    },
    -- for essences
    is_essence = {
        property = 'Is essence',
        func = core.factory.boolean_cast('is_essence'),
        default = false,
    },
    essence_level_restriction = {
        property = 'Has essence level restriction',
        func = core.factory.number_cast('essence_level_restriction'),
    },
    essence_tier = {
        property = 'Has essence tier',
        func = core.factory.number_cast('essence_tier'),
    },
    --
    -- hideout doodads (HideoutDoodads.dat)
    --
    is_master_doodad = {
        property = 'Is master doodad',
        func = core.factory.boolean_cast('is_master_doodad'),
    },
    master = {
        property = 'Is sold by master',
        -- todo validate against list of master names
        func = core.factory.table_cast('master', {key='full', tbl=m_game.constants.masters}),
    },
    master_level_requirement = {
        property = 'Has master level requirement',
        func = core.factory.number_cast('master_level_requirement'),
    },
    master_favour_cost = {
        property = 'Has master favour cost',
        func = core.factory.number_cast('master_favour_cost'),
    },
    variation_count = {
        property = 'Has variation count',
        func = core.factory.number_cast('variation_count'),
    },
    -- Propehcy
    prophecy_id = {
        property = 'Has prophecy id',
        func = nil,
    },
    prediction_text = {
        property = 'Has prophecy prediction text',
        func = nil,
    },
    seal_cost_normal = {
        property = 'Has prophecy seal cost in normal difficulty',
        func = core.factory.number_cast('seal_cost_normal'),
    },
    seal_cost_cruel = {
        property = 'Has prophecy seal cost in cruel difficulty',
        func = core.factory.number_cast('seal_cost_cruel'),
    },
    seal_cost_merciless = {
        property = 'Has prophecy seal cost in merciless difficulty',
        func = core.factory.number_cast('seal_cost_merciless'),
    },
    -- Divination cards
    card_art = {
        proprety = 'Has divination card art',
        func = function(tpl_args, frame)
            tpl_args.card_art = string.format('File:%s card art.png', tpl_args.name)
        end,
    },
    card_reward = {
        property = 'Has divinication card reward',
        func = nil,
    },
    -- ------------------------------------------------------------------------
    -- derived stats
    -- ------------------------------------------------------------------------
   
    -- For rarity != normal, rarity already verified
    base_item = {
        no_copy = true,
        property = 'Has base item',
        func = function(tpl_args, frame)
            tpl_args.base_item = tpl_args.base_item_data['Has name']
        end,
    },
    base_item_id = {
        no_copy = true,
        property = 'Has base item metadata id',
        func = function(tpl_args, frame)
            tpl_args.base_item_id = tpl_args.base_item_data['Has metadata id']
        end,
    },
    base_item_page = {
        no_copy = true,
        property = 'Has base item wiki page',
        func = function(tpl_args, frame)
            tpl_args.base_item_page = tpl_args.base_item_data[1]
        end,
    },
   
    name_list = {
        no_copy = true,
        property = 'Has names',
        func = function(tpl_args, frame)
            if tpl_args.name_list ~= nil then
                tpl_args.name_list = util.string.split(tpl_args.name_list, ', ')
                tpl_args.name_list[#tpl_args.name_list+1] = tpl_args.name
            else
                tpl_args.name_list = {tpl_args.name}
            end
        end,
    },
    name_list_lower = {
        no_copy = true,
        property = 'Has lowercase names',
        func = function(tpl_args, frame)
            tpl_args.name_list_lower = {}
            for index, value in ipairs(tpl_args.name_list) do
                tpl_args.name_list_lower[index] = mw.ustring.lower(value)
            end
        end,
    },
    gem_tags_difference = {
        no_copy = true,
        property = 'Has gem tags difference',
        func = function(tpl_args, frame)
            if tpl_args.gem_tags ~= nil then
                local gtags = {}
                -- copy tags
                for _, data in ipairs(m_game.constants.item.gem_tags) do
                     if data.full and data.full ~= '' then
                         gtags[data.full] = true
                     end
                     end
                 end
                 end
                 -- delete existing tags
                 return tpl_args['flask_duration_html'] ~= nil
                for _, tag in ipairs(tpl_args.gem_tags) do
            end,
                    gtags[tag] = nil
            func = core.factory.infobox_line{
                end
                 parts = {
               
                     {
                 -- add them as ordered list and not as hash table so it is consistent with the other gem tag list
                        key = 'flask_duration_html',
                tpl_args.gem_tags_difference = {}
                        color = false, -- html already has color
                for key, value in pairs(gtags) do
                    },
                     tpl_args.gem_tags_difference[#tpl_args.gem_tags_difference+1] = key
                 },
                end
                 fmt = i18n.tooltips.flask_duration,
            end
             },
        end,
         },
    },
         {
    frame_type = {
            show = h.factory.maybe_show_infobox_line{
        no_copy = true,
                keys = {'charges_per_use_html', 'charges_max_html'},
        property = nil,
             },
        func = function(tpl_args, frame)
            func = core.factory.infobox_line{
            if tpl_args.name == 'Prophecy' or tpl_args.base_item == 'Prophecy' then
                 parts = {
                 tpl_args.frame_type = 'prophecy'
                     {
                 return
                        key = 'charges_per_use_html',
            end
                        color = false, -- html already has color
       
                    },
            local var = core.class_specifics[tpl_args.class]
                    {
            if var ~= nil and var.frame_type ~= nil then
                        key = 'charges_max_html',
                tpl_args.frame_type = var.frame_type
                        color = false, -- html already has color
                return
                    },
             end
                },
           
                fmt = i18n.tooltips.flask_charges_per_use,
            tpl_args.frame_type = string.lower(tpl_args.rarity)
            },
        end,
         },
    },
         {
    --
            show = h.factory.maybe_show_infobox_line{
    -- args populated by mod validation
                keys = {'buff_stat_text'},
    --
                conditions = {processed = true},
    mods = {
            },
        no_copy = true,
            func = core.factory.infobox_line{
         property = 'Has mod ids',
                parts = {
         default = {},
                    {
    },
                        key = 'buff_stat_text',
    implicit_mods = {
                        color = 'mod',
        property = 'Has implicit mod ids',
                    },
        property_func = function (tpl_args)
                 },
            tpl_args.implicit_mods = util.string.split(tpl_args.implicit_mods, '<MANY>')
             },
             for _, modid in ipairs(tpl_args.implicit_mods) do
         },
                tpl_args.mods[#tpl_args.mods+1] = modid
         -- Armor
                 tpl_args._mods[#tpl_args._mods+1] = {
         {
                     result=nil,
             show = h.factory.maybe_show_infobox_line{
                    modid=modid,
                 keys = {'block_html'},
                    type='implicit',
             },
                }
            func = core.factory.infobox_line{
            end
                parts = {
        end,
                    {
        default = {},
                        key = 'block_html',
    },
                        color = false, -- html already has color
    explicit_mods = {
                        hide_default = 0,
        no_copy = true,
                        hide_default_key = 'block',
        property = 'Has explicit mod ids',
                    },
        default = {},
                },
    },
                fmt = i18n.tooltips.chance_to_block,
    physical_damage_html = {
             },
        no_copy = true,
        property = nil,
        func = core.factory.damage_html{key='physical'},
    },
    fire_damage_html = {
         no_copy = true,
         property = nil,
        func = core.factory.damage_html{key='fire'},
    },
    cold_damage_html = {
        no_copy = true,
        property = nil,
        func = core.factory.damage_html{key='cold'},
    },
    lightning_damage_html = {
        no_copy = true,
        property = nil,
        func = core.factory.damage_html{key='lightning'},
    },
    chaos_damage_html = {
        no_copy = true,
        property = nil,
        func = core.factory.damage_html{key='chaos'},
    },
    damage_avg = {
        no_copy = true,
        property = 'Has average damage',
        func = function(tpl_args, frame)
            local dmg = {min=0, max=0}
            for key, _ in pairs(dmg) do
                 for _, data in ipairs(m_game.constants.damage_types) do
                    dmg[key] = dmg[key] + tpl_args[string.format('%s_damage_%s_range_average', data.short_lower, key)]
                end
            end
           
            dmg = (dmg.min + dmg.max) / 2
           
             tpl_args.damage_avg = dmg
        end,
    },
    damage_html = {
         no_copy = true,
         property = 'Has damage HTML',
         func = function(tpl_args, frame)
             local text = {}
            for _, data in ipairs(m_game.constants.damage_types) do
                 local value = tpl_args[data.short_lower .. '_damage_html']
                if value ~= nil then
                    text[#text+1] = value
                end
            end
            if #text > 0 then
                tpl_args.damage_html = table.concat(text, '<br>')
             end
        end,
    },
    jewel_radius = {
        no_copy = true,
        property = 'Has jewel radius',
        func = core.factory.copy_stats{key='jewel_radius', stat_key='local_jewel_effect_base_radius'}
    },
    jewel_radius_html = {
        no_copy = true,
        property = 'Has jewel radius HTML',
        func = function(tpl_args, frame)
            if tpl_args.jewel_radius then
                tpl_args.jewel_radius_html = string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[tpl_args.jewel_radius] or '?'), tpl_args.jewel_radius)
            end
        end,
    },
}
 
core.stat_map = {
    range = {
        property = 'Has weapon range',
        stats_add = {
             'local_weapon_range_+',
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
            fmt = '%i',
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
         },
         },
    },
        {
    physical_damage_min = {
            show = h.factory.maybe_show_infobox_line{
        property = 'Has minimum physical damage',
                keys = {'evasion_html'},
        stats_add = {
            },
            'local_minimum_added_physical_damage',
            func = core.factory.infobox_line{
        },
                parts = {
        stats_increased = {
                    {
            'local_physical_damage_+%',
                        key = 'evasion_html',
        },
                        color = false, -- html already has color
        minimum = 0,
                        hide_default = 0,
        html_fmt_options = {
                        hide_default_key = 'evasion',
             fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.evasion,
             },
         },
         },
    },
        {
    physical_damage_max = {
            show = h.factory.maybe_show_infobox_line{
        property = 'Has maximum physical damage',
                keys = {'energy_shield_html'},
        stats_add = {
            },
            'local_maximum_added_physical_damage',
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
         },
         },
         stats_increased = {
         {
             'local_physical_damage_+%',
            show = h.factory.maybe_show_infobox_line{
                keys = {'ward_html'},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'ward_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'ward',
                    },
                },
                fmt = i18n.tooltips.ward,
            },
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             fmt = '%i',
                keys = {'movement_speed'},
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%i%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
         },
         },
    },
        -- Stackables
    fire_damage_min = {
        {
        default = 0,
            show = h.factory.maybe_show_infobox_line{
        property = 'Has minimum fire damage',
                keys = {'stack_size'},
        stats_add = {
                conditions = {processed = true},
             'local_minimum_added_fire_damage',
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
             },
         },
         },
         minimum = 0,
         -- Essences
        html_fmt_options = {
        {
             color = 'fire',
            show = h.factory.maybe_show_infobox_line{
            fmt = '%i',
                keys = {'essence_level'},
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
         },
         },
    },
        -- Oils
    fire_damage_max = {
        {
        default = 0,
            show = h.factory.maybe_show_infobox_line{
        property = 'Has maximum fire damage',
                keys = {'blight_item_tier'},
        stats_add = {
                conditions = {processed = true},
             'local_maximum_added_fire_damage',
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
             },
         },
         },
         minimum = 0,
         -- Tattoos
        html_fmt_options = {
        {
             color = 'fire',
            show = h.factory.maybe_show_infobox_line{
            fmt = '%i',
                keys = {'tattoo_target'},
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_target',
                    },
                },
                fmt = i18n.tooltips.tattoo_target,
            },
         },
         },
    },
        {
    cold_damage_min = {
            show = h.factory.maybe_show_infobox_line{
        default = 0,
                keys = {'tattoo_limit'},
        property = 'Has minimum cold damage',
                conditions = {processed = true},
        stats_add = {
            },
             'local_minimum_added_cold_damage',
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_limit',
                    },
                },
                fmt = i18n.tooltips.tattoo_limit,
             },
         },
         },
         minimum = 0,
         -- Harvest seeds (upper section)
        html_fmt_options = {
        {
             color = 'cold',
            show = h.factory.maybe_show_infobox_line{
            fmt = '%i',
                keys = {'seed_tier'},
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
         },
         },
    },
        {
    cold_damage_max = {
            show = h.factory.maybe_show_infobox_line{
        default = 0,
                keys = {'seed_tier'},
        property = 'Has maximum cold damage',
                conditions = {processed = true},
        stats_add = {
            },
             'local_maximum_added_cold_damage',
            func = function (tpl_args)
                return i18n.tooltips.seed_monster
             end,
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             color = 'cold',
                keys = {'seed_type_html'},
            fmt = '%i',
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
         },
         },
    },
        {
    lightning_damage_min = {
            show = h.factory.maybe_show_infobox_line{
        default = 0,
                keys = {'seed_growth_cycles'},
        property = 'Has minimum lightning damage',
                conditions = {processed = true},
        stats_add = {
            },
             'local_minimum_added_lightning_damage',
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
             },
         },
         },
         minimum = 0,
         -- Heist
         html_fmt_options = {
         {
            color = 'lightning',
            show = h.factory.maybe_show_infobox_line{
             fmt = '%i',
                keys = {'heist_required_npcs'},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
         },
         },
    },
        -- Sentinels
    lightning_damage_max = {
        {
        default = 0,
            show = h.factory.maybe_show_infobox_line{
        property = 'Has maximum lightning damage',
                keys = {'sentinel_duration'},
        stats_add = {
                conditions = {processed = true},
             'local_maximum_added_lightning_damage',
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_duration',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_duration,
             },
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             color = 'lightning',
                keys = {'sentinel_empowers'},
            fmt = '%i',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowers',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowers,
            },
         },
         },
    },
        {
    chaos_damage_min = {
            show = h.factory.maybe_show_infobox_line{
        default = 0,
                keys = {'sentinel_empowerment'},
        property = 'Has minimum chaos damage',
                conditions = {processed = true},
        stats_add = {
            },
             'local_minimum_added_chaos_damage',
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowerment',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowerment,
             },
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
            color = 'chaos',
                keys = {'sentinel_monster', 'sentinel_monster_level'},
            fmt = '%i',
                conditions = {processed = true},
        },
            },
    },
            func = core.factory.infobox_line{
    chaos_damage_max = {
                parts = {
        default = 0,
                    {
        property = 'Has maximum chaos damage',
                        key = 'sentinel_monster',
        stats_add = {
                    },
             'local_maximum_added_chaos_damage',
                    {
                        key = 'sentinel_monster_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_can_only_empower,
             },
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             color = 'chaos',
                keys = {'sentinel_charge'},
            fmt = '%i',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_charge',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_charge,
            },
         },
         },
    },
        -- Corpse items
    critical_strike_chance = {
        {
        property = 'Has critical strike chance',
            show = h.factory.maybe_show_infobox_line{
        stats_add = {
                keys = {'monster_category_html'},
             'local_critical_strike_chance',
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'monster_category_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.monster_category,
            },
         },
         },
         stats_increased = {
         -- Embers of the Allflame
             'local_critical_strike_chance_+%',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_size_html'},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'pack_size_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.pack_size,
            },
         },
         },
         stats_override = {
 
            ['local_weapon_always_crit'] = {min=100, max=100},
         {
        },
            show = h.factory.maybe_show_infobox_line{
        minimum = 0,
                keys = {'pack_leader_chance'},
        html_fmt_options = {
                conditions = {processed = true},
            fmt = '%.2f%%',
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                        },
                    },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                }(tpl_args)
            end,
         },
         },
     },
     },
     attack_speed = {
     -- Requirements
        property = 'Has attack speed',
    {
        stats_increased = {
        -- Talismans display their tier right above requirements
             'local_attack_speed_+%',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
         },
         },
         minimum = 0,
         -- Equipment requirements
        html_fmt_options = {
        {
            fmt = '%.2f',
            show = true, -- Requires...
            func = function (tpl_args)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                        hide = function (tpl_args, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                    }
                end
                return core.factory.infobox_line{
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.requires,
                }(tpl_args)
            end,
         },
         },
    },
        -- Tattoo requirements
    flask_life = {
        {
        property = 'Has flask life recovery',
            show = h.factory.maybe_show_infobox_line{
        stats_add = {
                keys = {'tattoo_min_adjacent'},
             'local_flask_life_to_recover',
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_min_adjacent',
                        fmt = '%i',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_min_adjacent,
            },
         },
         },
         stats_increased = {
         {
             'local_flask_life_to_recover_+%',
            show = h.factory.maybe_show_infobox_line{
            'local_flask_amount_to_recover_+%',
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_max_adjacent',
                        fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_max_adjacent,
            },
         },
         },
         html_fmt_options = {
         -- Heist gear requirements
             fmt = '%i',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                    },
                    {
                        key = 'heist_required_job',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
         },
         },
     },
     },
     flask_mana = {
     -- Gem description
         property = 'Has flask mana recovery',
    {
         stats_add = {
         class = 'tc -gemdesc',
            'local_flask_mana_to_recover',
         {
        },
            show = h.factory.maybe_show_infobox_line{
        stats_increased = {
                keys = {'gem_description'},
             'local_flask_mana_to_recover_+%',
             },
             'local_flask_amount_to_recover_+%',
             func = h.factory.display_raw_value('gem_description'),
         },
         },
     },
     },
     flask_duration = {
     -- Gem stats
         property = 'Has flask duration',
    {
         stats_increased = {
         class = 'tc -mod',
             'local_flask_duration_+%',
         {
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
             func = h.factory.display_raw_value('stat_text'),
         },
         },
         stats_increased_inverse = {
         {
             'local_flask_recovery_speed_+%',
            -- Gem quality selector widget
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
            end,
             func = function (tpl_args)
                local html = mw.html.create()
                    :tag('br'):done()
                local widget = html:tag('span')
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                end
                widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
            end,
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            -- Superior quality bonus
            fmt = '%.2f',
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality_type1_stat_text',
                        color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                    },
                },
                fmt = ' <br> %s',
            },
         },
         },
     },
     },
     charges_per_use = {
     -- Implicit stats
         property = 'Has flask charges per use',
    {
         stats_increased = {
         class = 'tc -mod',
            'local_charges_used_+%',
         {
        },
            show = h.factory.maybe_show_infobox_line{
        minimum = 0,
                keys = {'implicit_stat_text'},
        html_fmt_options = {
            },
            fmt = '%i',
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                end
                return tpl_args.implicit_stat_text
            end,
         },
         },
     },
     },
     charges_max = {
     -- Explicit stats
         property = 'Has maximum flask charges',
    {
         stats_add = {
         class = 'tc -mod',
            'local_extra_max_charges',
         {
        },
            show = h.factory.maybe_show_infobox_line{
        stats_increased = {
                keys = {'explicit_stat_text'},
            'local_max_charges_+%',
            },
        },
            func = function (tpl_args)
        minimum = 0,
                if tpl_args._infobox_container == 'inline' then
        html_fmt_options = {
                    return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
             fmt = '%i',
                end
                return tpl_args.explicit_stat_text
             end,
         },
         },
     },
     },
     block = {
     -- Experience
        property = 'Has block',
    --[[{
        stats_add = {
        {
            'local_additional_block_chance_%',
            show = h.factory.maybe_show_infobox_line{
                keys = {'experience'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
         },
         },
         minimum = 0,
    },]]--
         html_fmt_options = {
    -- Harvest seeds (lower section)
            fmt = '%i%%',
    {
        },
         class = 'tc -mod',
    },
         {
    armour = {
            show = h.factory.maybe_show_infobox_line{
        property = 'Has armour',
                keys = {'seed_consumed_wild_lifeforce_percentage'},
        stats_add = {
                conditions = {processed = true},
             'local_base_physical_damage_reduction_rating',
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
             end
         },
         },
         stats_increased = {
         {
            'local_physical_damage_reduction_rating_+%',
            show = h.factory.maybe_show_infobox_line{
             'local_armour_and_energy_shield_+%',
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
             'local_armour_and_evasion_+%',
                conditions = {processed = true},
             'local_armour_and_evasion_and_energy_shield_+%',
             },
             func = function (tpl_args)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
             end
         },
         },
         minimum = 0,
         {
         html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             fmt = '%i',
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
         {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
             func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                    },
                    {
                        key = 'seed_type_html',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
         },
         },
     },
     },
     evasion = {
     {
         property = 'Has evasion',
         class = 'tc -crafted',
         stats_add = {
         {
            'local_base_evasion_rating',
            show = h.factory.maybe_show_infobox_line{
        },
                keys = {'seed_effect'},
        stats_increased = {
                conditions = {processed = true},
            'local_evasion_rating_+%',
             },
            'local_evasion_and_energy_shield_+%',
             func = h.factory.display_raw_value('seed_effect'),
            'local_armour_and_evasion_+%',
             'local_armour_and_evasion_and_energy_shield_+%',
        },
        minimum = 0,
        html_fmt_options = {
             fmt = '%i',
         },
         },
     },
     },
     energy_shield = {
     -- Description
         property = 'Has energy shield',
    {
         stats_add = {
         class = 'tc -mod',
            'local_energy_shield'
         {
        },
            show = h.factory.maybe_show_infobox_line{
        stats_increased = {
                keys = {'description'},
            'local_energy_shield_+%',
                conditions = {processed = true},
             'local_armour_and_energy_shield_+%',
             },
            'local_evasion_and_energy_shield_+%',
             func = h.factory.display_raw_value('description'),
             'local_armour_and_evasion_and_energy_shield_+%',
         },
         },
         stats_override = {
         --[[{
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
         },
         },
         minimum = 0,
         {
        html_fmt_options = {
            show = h.factory.maybe_show_infobox_line{
             fmt = '%i',
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
             },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
         },
         },
    },
        {
    required_dexterity = {
            show = h.factory.maybe_show_infobox_line{
        property = 'Has dexterity requirement',
                keys = {'plant_booster_lifeforce'},
        stats_add = {
                conditions = {processed = true},
             'local_dexterity_requirement_+'
             },
        },
            func = core.factory.infobox_line{
        stats_increased = {
                parts = {
            'local_dexterity_requirement_+%',
                    {
            'local_attribute_requirements_+%',
                        key = 'plant_booster_lifeforce',
        },
                        fmt = '%s%%',
        stats_override = {
                    },
             ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
                },
         },
                fmt = i18n.tooltips.plant_booster_lifeforce,
         minimum = 0,
             },
        html_fmt_options = {
         },]]
             fmt = '%i',
         {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('monster_abilities'),
         },
         },
     },
     },
     required_intelligence = {
     -- Variations (for hideout decorations)
         property = 'Has intelligence requirement',
    {
         stats_add = {
         class = 'tc -mod',
             'local_intelligence_requirement_+'
         {
        },
             show = h.factory.maybe_show_infobox_line{
        stats_increased = {
                keys = {'variation_count'},
            'local_intelligence_requirement_+%',
                conditions = {processed = true},
            'local_attribute_requirements_+%',
            },
        },
            func = function (tpl_args)
        stats_override = {
                if tpl_args.variation_count > 1 then
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
        },
                end
        minimum = 0,
                return nil
        html_fmt_options = {
            end,
            fmt = '%i',
         },
         },
     },
     },
     required_strength = {
     -- Corrupted
         property = 'Has strength requirement',
    {
         stats_add = {
         class = 'tc -corrupted',
             'local_strength_requirement_+'
         {
        },
             show = h.factory.maybe_show_infobox_line{
        stats_increased = {
                keys = {'is_corrupted'},
            'local_strength_requirement_+%',
                conditions = {processed = true},
            'local_attribute_requirements_+%',
            },
        },
            func = function (tpl_args)
        stats_override = {
                if tpl_args.is_corrupted then
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
                    return i18n.tooltips.corrupted
        },
                end
        minimum = 0,
                return nil
        html_fmt_options = {
             end,
             fmt = '%i',
         },
         },
     },
     },
     map_area_level = {
     -- Mirrored
        property = 'Has map area level',
        stats_override = {
            ['map_item_level_override'] = true,
        },
    },
}
 
core.dps_map = {
     {
     {
         name = 'physical_dps',
         class = 'tc -mod',
         property = 'physical damage per second',
         {
        damage_args = {'physical_damage', },
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('pDPS', 'physical damage per second'),
                keys = {'is_mirrored'},
        html_fmt_options = {
                conditions = {processed = true},
            color = 'value',
            },
             fmt = '%.1f',
            func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
             end,
         },
         },
     },
     },
    -- Unmodifiable
     {
     {
         name = 'fire_dps',
         class = 'tc -mod',
         property = 'fire damage per second',
         {
        damage_args = {'fire_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('Fire DPS', 'fire damage per second'),
                keys = {'is_unmodifiable'},
        html_fmt_options = {
                conditions = {processed = true},
             color = 'fire',
             },
             fmt = '%.1f',
             func = function (tpl_args)
                if tpl_args.is_unmodifiable then
                    return i18n.tooltips.unmodifiable
                end
                return nil
            end,
         },
         },
     },
     },
    -- Flavour text
     {
     {
         name = 'cold_dps',
         class = 'tc -flavour',
         property = 'cold damage per second',
         {
        damage_args = {'cold_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('Cold DPS', 'cold damage per second'),
                keys = {'flavour_text'},
        html_fmt_options = {
                conditions = {processed = true},
             color = 'cold',
             },
             fmt = '%.1f',
             func = h.factory.display_raw_value('flavour_text'),
         },
         },
     },
     },
    -- Prophecy text
     {
     {
         name = 'lightning_dps',
         class = 'tc -value',
         property = 'lightning damage per second',
         {
        damage_args = {'lightning_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('Light. DPS', 'lightning damage per second'),
                keys = {'prediction_text'},
        html_fmt_options = {
                conditions = {processed = true},
             color = 'lightning',
             },
             fmt = '%.1f',
             func = h.factory.display_raw_value('prediction_text'),
         },
         },
     },
     },
    -- Can not be traded or modified
     {
     {
         name = 'chaos_dps',
         class = 'tc -canttradeormodify',
         property = 'chaos damage per second',
         {
        damage_args = {'chaos_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('Chaos DPS', 'chaos damage per second'),
                keys = {'cannot_be_traded_or_modified'},
        html_fmt_options = {
                conditions = {processed = true},
             color = 'chaos',
             },
             fmt = '%.1f',
             func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
         },
         },
     },
     },
    -- Help text
     {
     {
         name = 'elemental_dps',
         class = 'tc -help',
         property = 'elemental damage per second',
         {
        damage_args = {'fire_damage', 'cold_damage', 'lightning_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('eDPS', 'elemental damage (i.e. fire/cold/lightning) per second'),
                keys = {'help_text'},
        html_fmt_options = {
                conditions = {processed = true},
             color = 'value',
             },
             fmt = '%.1f',
             func = h.factory.display_raw_value('help_text'),
         },
         },
     },
     },
    -- Account-bound
     {
     {
         name = 'poison_dps',
         class = 'tc -mod',
         property = 'poison damage per second',
         {
        damage_args = {'physical_damage', 'chaos_damage'},
            show = h.factory.maybe_show_infobox_line{
        label = util.html.abbr('Poison DPS', 'poison damage (i.e. physical/chaos) per second'),
                keys = {'is_account_bound'},
        html_fmt_options = {
                conditions = {processed = true},
            color = 'value',
            },
            fmt = '%.1f',
            func = function (tpl_args)
        },
                if tpl_args.is_account_bound then
    },
                    return i18n.tooltips.account_bound
    {
                end
        name = 'dps',
                return nil
        property = 'damage per second',
             end,
        damage_args = {'physical_damage', 'fire_damage', 'cold_damage', 'lightning_damage', 'chaos_damage'},
        label = util.html.abbr('DPS', 'total damage (i.e. physical/fire/cold/lightning/chaos) per second'),
        html_fmt_options = {
            color = 'value',
             fmt = '%.1f',
         },
         },
     },
     },
}
}


-- base item is default, but will be validated later
--
-- Notes:
-- This is meant to show additional information about the item in a separate infobox
-- inventory_icon must always be before alternate_art_inventory_icons
--
core.default_args = {'class', 'rarity', 'name', 'name_list', 'name_list_lower', 'size_x', 'size_y', 'drop_enabled', 'drop_level', 'drop_level_maximum', 'required_level', 'required_level_final', 'inventory_icon', 'alternate_art_inventory_icons', 'flavour_text', 'help_text', 'tags', 'metadata_id', 'is_corrupted', 'mods', 'implicit_mods', 'explicit_mods'}
c.extra_display_groups = {
-- frame_type is needed in stat_text
    {
core.late_args = {'frame_type', 'implicit_stat_text', 'explicit_stat_text', 'stat_text'}
        heading = i18n.tooltips.extra_info,
core.prophecy_args = {'prophecy_id', 'prediction_text', 'seal_cost_normal', 'seal_cost_cruel', 'seal_cost_merciless'}
        class = '',
core.class_groups = {
        {
    flasks = {
            show = h.factory.maybe_show_infobox_line{
        keys = {['Life Flasks'] = true, ['Mana Flasks'] = true, ['Hybrid Flasks'] = true, ['Utility Flasks'] = true, ['Critical Utility Flasks'] = true},
                keys = {'atlas_connections'},
        args = {'flask_duration', 'charges_max', 'charges_per_use'},
                conditions = {processed = true},
    },
            },
    weapons = {
            func = function (tpl_args)
        keys = {['Claws'] = true, ['Daggers'] = true, ['Wands'] = true, ['One Hand Swords'] = true, ['Thrusting One Hand Swords'] = true, ['One Hand Axes'] = true, ['One Hand Maces'] = true, ['Bows'] = true, ['Staves'] = true, ['Two Hand Swords'] = true, ['Two Hand Axes'] = true, ['Two Hand Maces'] = true, ['Sceptres'] = true, ['Fishing Rods'] = true},
                local fields = {
        args = {'required_dexterity', 'required_intelligence', 'required_strength', 'critical_strike_chance', 'attack_speed', 'physical_damage_min', 'physical_damage_max', 'range'},
                    [false] = {
        late_args = {'physical_damage_html', 'fire_damage_html', 'cold_damage_html', 'lightning_damage_html', 'chaos_damage_html', 'damage_avg', 'damage_html'},
                        value = '✗',
    },
                        sort = 0,
    gems = {
                        class = 'table-cell-xmark',
        keys = {['Active Skill Gems'] = true, ['Support Skill Gems'] = true},
                    },
        args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'primary_attribute', 'gem_tags', 'gem_tags_difference'},
                    [true] = {
    },
                        value = '✓',
    armor = {
                        sort = 1,
        keys = {['Gloves'] = true, ['Boots'] = true, ['Body Armours'] = true, ['Helmets'] = true, ['Shields'] = true},
                        class = 'table-cell-checkmark',
        args = {'required_dexterity', 'required_intelligence', 'required_strength', 'armour', 'energy_shield', 'evasion'},
                    },
    },
                }
    stackable = {
               
        keys = {['Currency'] = true, ['Stackable Currency'] = true, ['Hideout Doodads'] = true, ['Microtransactions'] = true, ['Divination Card'] = true},
                local tbl = mw.html.create('table')
        args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
                tbl
    },
                    :addClass('wikitable')
}
                    :attr('style', 'width:100%;')
 
                    :tag('tr')
core.class_specifics = {
                        :tag('th')
    ['Amulets'] = {
                            :attr('colspan', 6)
         args = {'is_talisman'},
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                   
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                   
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
               
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
               
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
               
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                   
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :addClass(field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
               
                return tostring(tbl)
            end
         },
     },
     },
     ['Life Flasks'] = {
     -- Acquisition
         args = {'flask_life'},
    {
    },
         heading = i18n.tooltips.acquisition,
    ['Mana Flasks'] = {
        {
        args = {'flask_mana'},
            show = function (tpl_args)
    },
                if tpl_args.is_in_game == false then
    ['Hybrid Flasks'] = {
                    return true
        args = {'flask_life', 'flask_mana'},
                end
    },
                return false
    ['Utility Flasks'] = {
            end,
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
            func = function (tpl_args)
    },
                local span = mw.html.create('span')
    ['Critical Utility Flasks'] = {
                span
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
                    :addClass('infobox-disabled-drop')
    },
                    :wikitext(i18n.tooltips.not_in_game)
    ['Active Skill Gems'] = {
                    :done()
        args = {'skill_screenshot', 'gem_icon'},
                return tostring(span)
        defaults = {
             end,
            help_text = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.',
            size_x = 1,
             size_y = 1,
         },
         },
         frame_type = 'gem',
         {
    },
            show = function (tpl_args)
    ['Support Skill Gems'] = {
                if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
        args = {'support_gem_letter_html'},
                    return true
        defaults = {
                end
            help_text = 'This is a Support Gem. It does not grant a bonus to your character, but skills in sockets connected to it. Place into an item socket connected to a socket containing the Active Skill Gem you wish to augment. Right click to remove from a socket.',
                return false
            size_x = 1,
            end,
             size_y = 1,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
             end,
         },
         },
         frame_type = 'gem',
         {
    },
            show = function (tpl_args)
    ['Shields'] = {
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
        args = {'block'},
                    return true
    },
                end
    ['Maps'] = {
                return false
        args = {'map_tier', 'map_guild_character', 'map_area_id', 'map_area_level', 'unique_map_area_id', 'unique_map_area_level', 'unique_map_guild_character'},
             end,
        skip_stat_lines = {
             func = function (tpl_args)
            '%d+%% increased Quantity of Items found in this Area',
                local span = mw.html.create('span')
            '%d+%% increased Rarity of Items found in this Area',
                span
             '%+%d+%% Monster pack size',
                    :addClass('infobox-restricted-drop')
             -- ranges
                    :wikitext(i18n.tooltips.drop_restricted)
            '%(%d+%-%d+%)%% increased Quantity of Items found in this Area',
                    :done()
            '%(%d+%-%d+%)%% increased Rarity of Items found in this Area',
                return tostring(span)
            '%+%(%d+%-%d+%)%% Monster pack size',
             end,
        },
    },
    ['Currency'] = {
        frame_type = 'currency',
    },
    ['Stackable Currency'] = {
        args = {'is_essence', 'essence_level_restriction', 'essence_tier'},
        frame_type = 'currency',
    },
    ['Microtransactions'] = {
        frame_type = 'currency',
    },
    ['Hideout Doodads'] = {
        args = {'is_master_doodad', 'master', 'master_level_requirement', 'master_favour_cost', 'variation_count'},
        defaults = {
             help_text = 'Right click on this item then left click on a location on the ground to create the object.',
         },
         },
         frame_type = 'currency',
         {
    },
            show = h.factory.maybe_show_infobox_line{
    ['Jewel'] = {
                keys = {'drop_level'},
        late_args = {'jewel_radius', 'jewel_radius_html'},
                conditions = {processed = true},
        defaults = {
            },
            help_text = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.drop_level,
            },
         },
         },
         skip_stat_lines = {
         {
             'Limited to %d+ %(Hidden%)',
            show = h.factory.maybe_show_infobox_line{
             'Jewel has a radius of %d+ %(Hidden%)',
                keys = {'acquisition_tags'},
                conditions = {processed = true},
             },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                return table.concat(tags, ' • ')
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_areas_html'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('drop_areas_html'),
         },
         },
    },
    ['Quest Items'] = {
        frame_type = 'quest',
    },
    ['Divination Card'] = {
        args = {'card_art', 'card_reward'},
        frame_type = 'divicard',
    },
    ['Labyrinth Item'] = {
        frame_type = 'currency',
    },
    ['Labyrinth Trinket'] = {
        args = {'description', 'buff_icon'},
        frame_type = 'currency',
    },
}
-- add defaults from class specifics and class groups
core.item_classes = {}
function core.build_item_classes()
    for _, data in ipairs(m_game.constants.item.class) do
        core.item_classes[data['full']] = {
            args = xtable:new(),
            late_args = xtable:new(),
            defaults = {},
        }
    end
    for _, row in pairs(core.class_groups) do
        for k, _ in pairs(row.keys) do
            core.item_classes[k].args:insertT(row.args)
            if row.late_args ~= nil then
                core.item_classes[k].late_args:insertT(row.late_args)
            end
        end
    end
    for k, row in pairs(core.class_specifics) do
        if row.args ~= nil then
            core.item_classes[k].args:insertT(row.args)
        end
        if row.late_args ~= nil then
            core.item_classes[k].late_args:insertT(row.late_args)
        end
        if row.defaults ~= nil then
            for key, value in pairs(row.defaults) do
                core.item_classes[k].defaults[key] = value
            end
      end
    end
end
-- GroupTable -> RowTable -> formatter function
--
--
core.display_groups = {
    -- Tags, stats, level, etc
    {
         {
         {
             args = {'cosmetic_type'},
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'drop_text'},
                 options = {
                conditions = {processed = true},
                    [1] = {
                        key = 'cosmetic_type',
                        fmt = '%s',
                        color = 'default'
                    },
                },
             },
             },
            func = h.factory.display_raw_value('drop_text'),
         },
         },
         {
         {
             args = function(tpl_args, frame)
             show = h.factory.maybe_show_infobox_line{
                 if tpl_args.class == nil then
                 keys = {'seal_cost'},
                    return false
                 conditions = {processed = true},
                 end
             },
               
             func = core.factory.infobox_line{
                return core.class_groups.weapons.keys[tpl_args.class] ~= nil
                 parts = {
             end,
                     {
             func = core.factory.display_value{
                         key = 'seal_cost',
                 options = {
                        fmt = function (tpl_args, value)
                     [1] = {
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                         key = 'class',
                        end,
                         color = 'default',
                         color = 'currency',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.seal_cost,
             },
             },
         },
         },
    },
    {
        -- Vendor prices
        heading = i18n.tooltips.purchase_costs,
         {
         {
             args = {'gem_tags'},
             show = function (tpl_args)
             func = function(tpl_args, frame)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                 local out = {}
                    if #data > 0 then
                 for i, tag in ipairs(tpl_args.gem_tags) do
                        return true
                     out[#out+1] = string.format('[[:Category:%s (gem tag)|%s]]', tag, tag)
                    end
                end
                return false
            end,
             func = function (tpl_args)
                 local tbl = mw.html.create('table')
                tbl
                    --:addClass('wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                   
                 for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                     local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                 end
                 end
                  
                  
                 return table.concat(out, ', ')
                 return tostring(tbl)
             end,
             end,
         },
         },
    },
    {
        -- Vendor offer
        heading = i18n.tooltips.sell_price,
         {
         {
             args = {'support_gem_letter_html'},
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'sell_price_order'},
                 options = {
                    [1] = {
                        key = 'support_gem_letter_html',
                        before = 'Icon: ',
                    },
                },
             },
             },
            func = function (tpl_args)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
         },
         },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
         {
         {
             args = {'radius'},
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'physical_dps_html'},
                 options = {
            },
                    [1] = {
            func = core.factory.infobox_line{
                        key = 'radius',
                parts = {
                        before = 'Radius: ',
                     {
                        func = core.factory.descriptor_value{key='radius_description'},
                         key = 'physical_dps_html',
                    },
                         color = false, -- the html already contains the colour
                    [2] = {
                        key = 'radius_seceondary',
                        before = ' / ',
                        func = core.factory.descriptor_value{key='radius_secondary_description'},
                    },
                     [3] = {
                         key = 'radius_tertiary',
                        before = ' / ',
                         func = core.factory.descriptor_value{key='radius_tertiary_description'},
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.physical_dps,
             },
             },
         },
         },
        -- TODO: gem level here. Maybe put max level here?
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'fire_dps_html'},
                 type='gem',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'mana_cost',
                     {
                        hide_default = 100,
                         key = 'fire_dps_html',
                        fmt = function (tpl_args, frame)
                         color = false, -- the html already contains the colour
                            if tpl_args.has_percentage_mana_cost then
                                return '%i%%'
                            else
                                return '%i'
                            end
                        end,
                         before = function (tpl_args, frame)
                            if tpl_args.has_reservation_mana_cost then
                                return 'Mana Reserved: '
                            else
                                return 'Mana Cost: '
                            end
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.fire_dps,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'cold_dps_html'},
                 type='gem',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'mana_multiplier',
                     {
                        hide_default = 100,
                         key = 'cold_dps_html',
                        fmt = '%i%%',
                         color = false, -- the html already contains the colour
                         before = 'Mana Multiplier: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.cold_dps,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'lightning_dps_html'},
                 type='gem',
            },
                options = {
            func = core.factory.infobox_line{
                    [1] = {
                parts = {
                        key = 'vaal_souls_requirement',
                     {
                        hide_default = 0,
                         key = 'lightning_dps_html',
                        fmt = '%i (N) / ',
                         color = false, -- the html already contains the colour
                        before = 'Souls per use: ',
                    },
                    [2] = {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i (C) / ',
                        func = function (tpl_args, frame, value)
                            return value*1.5
                        end,
                    },
                     [3] = {
                         key = 'vaal_souls_requirement',
                         hide_default = 0,
                        fmt = '%i (M)',
                        func = function (tpl_args, frame, value)
                            return value*2
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.lightning_dps,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'chaos_dps_html'},
                 type='gem',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'vaal_stored_uses',
                     {
                         hide_default = 0,
                         key = 'chaos_dps_html',
                        fmt = '%i',
                         color = false, -- the html already contains the colour
                        before = 'Can store ',
                        after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.chaos_dps,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'elemental_dps_html'},
                 type='gem',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'stored_uses',
                     {
                         hide_default = 0,
                         key = 'elemental_dps_html',
                        fmt = '%i',
                         color = false, -- the html already contains the colour
                        before = 'Can store ',
                        after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.elemental_dps,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'poison_dps_html'},
                 type='gem',
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         key = 'cooldown',
                     {
                        hide_default = 0,
                         key = 'poison_dps_html',
                        fmt = '%.2f sec',
                         color = false, -- the html already contains the colour
                         before = 'Cooldown Time: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.poison_dps,
             },
             },
         },
         },
         {
         {
             args = {'cast_time'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'dps_html'},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         key = 'cast_time',
                 parts = {
                         hide_default = 0,
                     {
                        fmt = '%.2f sec',
                         key = 'dps_html',
                        before = 'Cast Time: ',
                         color = false, -- the html already contains the colour
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.dps,
             },
             },
         },
         },
    },
    -- Metadata
    {
        heading = i18n.tooltips.metadata,
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'class'},
                 type='gem',
                 conditions = {processed = true},
                 options = {
            },
                    [1] = {
            func = core.factory.infobox_line{
                        key = 'critical_strike_chance',
                parts = {
                        hide_default = 0,
                    {
                        fmt = '%.2f%%',
                         key = 'class',
                         before = 'Critical Strike Chance: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.item_class,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'metadata_id'},
                 type='gem',
                 conditions = {processed = true},
                 options = {
            },
                     [1] = {
            func = function (tpl_args)
                         key = 'damage_effectiveness',
                return core.factory.infobox_line{
                        hide_default = 100,
                     parts = {
                        fmt = '%i%%',
                         {
                         before = 'Damage Effectiveness: ',
                            key = 'metadata_id',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                         },
                     },
                     },
                 },
                    fmt = tostring(
             },
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                 }(tpl_args)
             end,
         },
         },
        {
    },
            args = {'projectile_speed'},
}
            func = core.factory.display_value{
 
                options = {
-- ----------------------------------------------------------------------------
                    [1] = {
-- Subroutines
                        key = 'projectile_speed',
-- ----------------------------------------------------------------------------
                        before = 'Projectile Speed: ',
 
                    },
local s = {}
                },
 
            },
-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.
         },
 
        -- Weapon only
function s.get_item_config(tpl_args)
         {
    -- Returns primary item configuration, based on item class
            args = {'physical_damage_html'},
 
            func = core.factory.display_value{
    local config = {
                options = {
         tables = {}, -- Table names that data may be stored to
                    [1] = {
         args = {}, -- Args to process early
                        key = 'physical_damage_html',
        late_args = {}, -- Args to process late
                        fmt = '%s',
        defaults = {}, -- Defaults based on item class
                        before = 'Physical Damage: '
    }
                    },
    for _, v in ipairs(cfg.tables) do
                },
        table.insert(config.tables, v)
            },      
    end
         },
    for _, v in ipairs(cfg.default_args) do
        {
        table.insert(config.args, v)
            args = nil,
    end
            func = function(tpl_args, frame)
    for _, v in ipairs(cfg.late_args) do
                local text = ''
         table.insert(config.late_args, v)
                for _, dtype in ipairs({'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}) do
    end
                    local value = tpl_args[dtype]
 
                     if value ~= nil then
    -- Process class_id
                         text = text .. ' ' .. value
    h.process_arguments(tpl_args, {'class_id'})
 
    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                     for _, v in ipairs(row[k]) do
                         table.insert(config[k], v)
                     end
                     end
                 end
                 end
               
            end
                if text ~= '' then
            if row['defaults'] then
                     return 'Elemental Damage:' .. text
                for k, v in pairs(row['defaults']) do
                 else
                     config['defaults'][k] = v
                     return
                end
            end
            break
        end
    end
    local class_specifics = cfg.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(extend_keys) do
            if class_specifics[k] then
                 for _, v in ipairs(class_specifics[k]) do
                     table.insert(config[k], v)
                 end
                 end
             end,     
             end
         },
         end
         {
         if class_specifics['defaults'] then
             args = {'chaos_damage_html'},
             for k, v in pairs(class_specifics['defaults']) do
            func = core.factory.display_value{
                 config['defaults'][k] = v
                 options = {
            end
                    [1] = {
        end
                        key = 'chaos_damage_html',
    end
                        fmt = '%s',
    return config
                        before='Chaos Damage: ',
end
                    },
 
                },
function s.process_quest_rewards(tpl_args)
            },     
    local rid = 1
         },
    local continue
         {
    tpl_args.quest_rewards = {}
            args = {'critical_strike_chance_html'},
    tpl_args.vendor_rewards = {}
            func = core.factory.display_value{
    repeat
                options = {
         continue = true
                    [1] = {
         local prefix = string.format('quest_reward%s_', rid)
                        key = 'critical_strike_chance_html',
       
                        fmt = '%s',
        local input_args = {
                        before = 'Critical Strike Chance: ',
            shared = {
                    },
                ['type'] = true,
                ['quest'] = false,  
                ['quest_id'] = false,  
                ['act'] = true,  
                ['class_ids'] = false,
                 },
                 },
            vendor = {
                ['npc'] = true,
            },
            quest = {
                ['sockets'] = false,
                ['item_level'] = false,
                ['rarity_id'] = false,
                ['notes'] = false,
             },
             },
         },
         }
         {
          
            args = {'attack_speed_html'},
        local rdata = {}
             func = core.factory.display_value{
       
                 options = {
        for key, is_required in pairs(input_args.shared) do
                     [1] = {
             rdata[key] = tpl_args[prefix .. key]
                        key = 'attack_speed_html',
            if is_required then
                        fmt = '%s',
                 if rdata[key] == nil then
                         before = 'Attacks per Second: ',
                    continue = false
                     },
                     break
                 },
                end
             },
            end
         },
        end
         -- Map only
       
         {
        if rdata.quest == nil or rdata.quest_id == nil then
             args = {'map_area_level'},
            continue = false
             func = core.factory.display_value{
        end
                 options = {
       
                     [1] = {
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
                         key = 'map_area_level',
            for key, is_required in pairs(input_args[rdata.type]) do
                         fmt = '%i',
                rdata[key] = tpl_args[prefix .. key]
                         before = 'Map Level: ',
                if is_required then
                     },
                    if rdata[key] == nil then
                 },
                         continue = false
             },
                        break
        },
                     end
        {
                 end
             args = {'map_tier'},
            end
             func = core.factory.display_value{
        else
                 options = {
             continue = false
                    [1] = {
         end
                        key = 'map_tier',
          
                        fmt = '%i',
         if continue then
                        before = 'Map Tier: ',
             rdata.classes = {}
                    },
             if rdata.class_ids ~= nil then
                },
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
             },
                 for index, class_id in ipairs(rdata.class_ids) do
         },
                     local class = m_game.constants.characters[class_id]  
         {
                    if class == nil then
            args = function(tpl_args, frame)
                         error(string.format('Class id %s is invalid', class_id))
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity == 'Normal'
                    else
             end,
                         rdata.class_ids[index] = class.str_id
            func = core.factory.display_value{
                         rdata.classes[index] = class.name
                options = {
                     end
                    [1] = {
                 end
                        key = 'map_guild_character',
             end
                        fmt = '%s',
           
                        before = util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': ',
           
                    },
             if rdata.item_level then
                },
                rdata.item_level = m_util.cast.number(rdata.item_level)
            },
            end
         },
           
         {
             if rdata.rarity_id then
             args = function(tpl_args, frame)
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity == 'Unique'
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
            end,
                 end
            func = core.factory.display_value{
            end
                options = {
           
                    [1] = {
            rdata._table = rdata.type .. '_rewards'
                        key = 'unique_map_guild_character',
            rdata.type = nil
                        fmt = '%s',
           
                        before = util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': ',
            tpl_args[rdata._table] = rdata
                    },
           
                },
            m_cargo.store(rdata)
            },
           
         },
             -- TODO: Verify quests and quest ids?
         {
        end
             args = nil,
          
             func = core.factory.display_value{
         rid = rid + 1
                 type = 'stat',
    until continue == false
                 options = {
end
                    [1] = {
 
                        key = 'map_item_drop_quantity_+%',
function s.process_base_item(tpl_args)
                        fmt = '+%i%%',
    if not tpl_args._flags.is_derived then
                         color = 'mod',
        if tpl_args.rarity_id ~= 'normal' then
                        before = 'Item Quantity: ',
             error(i18n.errors.missing_base_item)
                         hide_default = 0,
        end
                     },
        return
                 },
    end
             },
    m_item_util = m_item_util or require('Module:Item util')
         },
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
        end
    end
    qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    qargs.fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
        'items.class_id',
        'items.rarity_id',
         'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
         if arg_def.field ~= nil then
             qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
        end
    end
    qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
    local result = m_item_util.query_item({
        metadata_id = tpl_args.base_item_id,
        page = tpl_args.base_item_page,
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
    if result.error then
        result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
    end
 
    tpl_args.base_item = result['items.name']
    tpl_args.base_item_page = result['items._pageName']
    tpl_args.base_item_id = result['items.metadata_id']
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})
 
    tpl_args.base_item_icon = result['items.inventory_icon']
 
    -- Copy values
    for _, k in ipairs(tpl_args._base_item_args) do
         local arg_def = core.map[k]
         if arg_def.func_fetch ~= nil then
             arg_def.func_fetch(tpl_args)
        elseif arg_def.field ~= nil then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
             if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
            else
                 local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                 -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                    tpl_args[k] = value
                    if arg_def.func ~= nil then
                         tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                         arg_def.func_copy(tpl_args, tpl_args[k])
                     end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                 end
             end
        end
    end
 
    -- Fetch implicit mods from base item
    local mods = m_cargo.query(
        {'items' ,'item_mods'},
         {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
         {
         {
             args = nil,
             join = 'items._pageID=item_mods._pageID',
             func = core.factory.display_value{
             where = string.format(
                 type = 'stat',
                 'items._pageName="%s" AND item_mods.is_implicit=true',
                 options = {
                 tpl_args.base_item_page
                    [1] = {
            ),
                        key = 'map_item_drop_rarity_+%',
        }
                        fmt = '+%i%%',
    )
                        color = 'mod',
    tpl_args._base_implicit_mods = {}
                        before = 'Item Rarity: ',
    for _, row in ipairs(mods) do
                        hide_default = 0,
        table.insert(tpl_args._base_implicit_mods, {
                    },
            id = row['item_mods.id'],
                },
            stat_text = row['item_mods.text'],
            },
            is_implicit = true,
         },
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
         {
        })
             args = nil,
    end
             func = core.factory.display_value{
end
                type = 'stat',
 
                options = {
function s.process_mods(tpl_args)
                    [1] = {
    tpl_args._defined_implicit_mods = {}
                        key = 'map_pack_size_+%',
    tpl_args._mods = {}
                        fmt = '+%i%%',
 
                        color = 'mod',
    local function parse_mod_arg(tpl_args, type, index)
                        before = 'Monster Pack Size: ',
         local prefix = type .. index
                        hide_default = 0,
         local mod_data = {
                    },
             is_implicit = type == 'implicit',
                },
             is_explicit = type == 'explicit',
             },
            is_map_fragment_bonus = type == 'map_fragment_bonus',
         },
            is_random = false,
         -- Jewel Only
        }
         {
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
            args = nil,
 
             func = core.factory.display_value{
        -- By mod id
                type = 'stat',
        local value = tpl_args[prefix]
                 options = {
        if value ~= nil then
                     [1] = {
            mod_data.id = value
                        key = 'local_unique_item_limit',
            mod_data.stat_text = tpl_args[prefix .. '_text']
                        fmt = '%i',
            table.insert(mods_table, mod_data)
                        before = 'Limited to: ',
             return true
                    },
         end
                },
 
             },
         -- By list of possible mod ids
         },
         value = tpl_args[prefix .. '_random_list']
         {
        if value ~= nil then
            args = {'jewel_radius_html'},
             value = m_util.cast.table(value)
             func = core.factory.display_value{
            for _, id in ipairs(value) do
                options = {
                 local mod_data_copy = {}
                    [1] = {
                for k, v in pairs(mod_data) do
                        key = 'jewel_radius_html',
                     mod_data_copy[k] = v
                        fmt = '%s',
                end
                        before = 'Radius: ',
                mod_data_copy.id = id
                    },
                mod_data_copy.is_random = true
                },
                mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
             },
                table.insert(mods_table, mod_data_copy)
         },
            end
        --[[
            tpl_args._flags.random_mods = true
        {
             return true
            args = nil,
         end
            func = core.factory.display_value{
 
                type = 'stat',
         -- By stat text
                options = {
        value = tpl_args[prefix .. '_text']
                    [1] = {
        if value ~= nil then
                        key = 'local_jewel_effect_base_radius',
             mod_data.result = false -- Not stored in Cargo table
                        fmt = '%s',
            mod_data.stat_text = value
                        func = function(value)
            table.insert(mods_table, mod_data)
                            return string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[value] or '?'), value)
            tpl_args._flags.text_modifier = true
                        end,
            return true
                        before = 'Radius: ',
        end
                    },
 
                 },
        return false
             },
    end -- parse_mod_arg
         },]]--
 
         -- Flask only
    local types = {
        {
        'implicit',
             args = {'flask_mana_html', 'flask_duration_html'},
        'explicit',
            --func = core.factory.display_flask('flask_mana'),
        'map_fragment_bonus',
             func = core.factory.display_value{
    }
                 options = {
    for _, t in ipairs(types) do
                     [1] = {
        local i = 1
                        key = 'flask_mana_html',
        while parse_mod_arg(tpl_args, t, i) do
                        fmt = '%s',
             i = i + 1
                        before = 'Recovers ',
         end
                    },
    end
                    [2] = {
 
                        key = 'flask_duration_html',
    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
                        fmt = '%s',
    local implicit_mods = tpl_args._defined_implicit_mods or {}
                        before = ' Mana over ',
    if #implicit_mods == 0 then
                        after = ' seconds',
        implicit_mods = tpl_args._base_implicit_mods or {}
                    },
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                table.insert(mod_ids, mod_data.id)
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            table.insert(tpl_args._store_data, {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                 is_random = mod_data.is_random,
             })
         end
         local results = m_cargo.query(
            {'mods'},
             {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
             {
                 where = string.format(
                     'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
            mod_data.result = row
            if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                 }
                 }
             },
                for _, v in ipairs(args) do
         },
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
         {
                    if req > tpl_args[v] then
             args = {'flask_life_html', 'flask_duration_html'},
                        tpl_args[v] = req
             func = core.factory.display_value{
                    end
                 options = {
                end
                     [1] = {
             end
                        key = 'flask_life_html',
        end
                        fmt = '%s',
       
                        before = 'Recovers ',
         -- fetch stats
                    },
         results = m_cargo.query(
                    [2] = {
            {'mods', 'mod_stats'},
                        key = 'flask_duration_html',
             {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
                        fmt = '%s',
             {
                        before = ' Life over ',
                join = 'mods._pageID=mod_stats._pageID',
                        after = ' seconds',
                 where = string.format(
                    },
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
                     table.concat(mod_ids, '","')
                ),
            }
        )
        for _, row in ipairs(results) do
            -- Stat data
            local mod_data = mods[row['mods.id']]
            mod_data.result.stats = mod_data.result.stats or {}
            table.insert(mod_data.result.stats, row)
            local stat_id = row['mod_stats.id']
            local value = {
                min = tonumber(row['mod_stats.min']),
                max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
            core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
        end
       
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                 }
                 }
             },
             )
        },
              
        {
             for _, data in ipairs(results) do
             -- don't display for mana/life flasks
                local mod_data = mods[data['mods.id']]
             args = function(tpl_args, frame)
                if not mod_data.is_implicit then
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    local values = {
                     if tpl_args[k] ~= nil then
                        name = data['mod_sell_prices.name'],
                        return false
                        amount = tonumber(data['mod_sell_prices.amount']),
                    end
                    }
                     -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                 end
                 end
               
            end
                return tpl_args['flask_duration_html'] ~= nil
        end
            end,
    end
             func = core.factory.display_value{
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
                options = {
        local missing_sell_price = true
                    [1] = {
        for _, _ in pairs(tpl_args.sell_prices) do
                        key = 'flask_duration_html',
            missing_sell_price = false
                        before = 'Lasts ',
            break
                        after = ' Seconds',
        end
                        fmt = '%s',
       
                    },
        if missing_sell_price then
                },
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
            },
        end
         },
       
         {
        -- Set sell price on page
            args = {'charges_per_use_html', 'charges_max_html'},
        for name, amount in pairs(tpl_args.sell_prices) do
             func = core.factory.display_value{
             -- sell_price_order is defined in core.map.sell_prices_override
                options = {
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
                    [1] = {
            tpl_args._store_data[#tpl_args._store_data+1] = {
                        key = 'charges_per_use_html',
                _table = 'item_sell_prices',
                        before = 'Consumes ',
                amount = amount,
                        fmt = '%s',
                name = name,
                    },
            }
                     [2] = {
        end
                         key = 'charges_max_html',
        table.sort(tpl_args.sell_price_order)
                         before = ' of ',
    end
                         after = ' Charges on use',
end
                         fmt = '%s',
 
                     },
function s.process_stats(tpl_args)
                 },
    tpl_args._stats = tpl_args._stats or {}
             },
 
        },
    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
        {
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
            args = {'buff_stat_text'},
    for _, stat in ipairs(tpl_args.extra_stats) do
            func = core.factory.display_value{
        core.add_stat(tpl_args, stat.id, stat.value or stat)
                options = {
    end
                    [1] = {
   
                         key = 'buff_stat_text',
    -- Handle local item stat math - additions, increases, etc.
                         color = 'mod',
    for key, stat_def in pairs(core.stat_map) do
                     },
         local arg = stat_def.arg or key
                 },
         local value = {}
             },
        if type(arg) == 'table' then
         },
            value.min = tpl_args[arg.min]
        -- armor
             value.max = tpl_args[arg.max]
        {
            value.base_min = tpl_args[arg.min]
            args = {'block_html'},
            value.base_max = tpl_args[arg.max]
             func = core.factory.display_value{
        else
                 options = {
            value.min = tpl_args[arg]
                     [1] = {
            value.max = tpl_args[arg]
                         key = 'block_html',
            value.base = tpl_args[arg]
                         before = 'Chance to Block: ',
        end
                         fmt = '%s',
        if value.min ~= nil and value.max ~= nil then
                         hide_default = 0,
            -- Determine whether stat is overridden; if so, other calculations can be ignored
                         hide_default_key = 'block',
            local overridden = false
                     },
            if stat_def.stats_override then
                 },
                for id, v in pairs(stat_def.stats_override) do
             },
                     if tpl_args._stats[id] then
         },
                         -- If for some reason there is more than one of the same override stat, apply the final one.
         {
                         local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
             args = {'armour_html'},
                         if stat_value then
             func = core.factory.display_value{
                            if type(v) == 'table' then
                 options = {
                                value.min = v.min
                     [1] = {
                                value.max = v.max
                        key = 'armour_html',
                                overridden = true
                        before = 'Armour: ',
                            elseif v then -- Use the stat value
                        fmt = '%s',
                                value.min = stat_value.min
                        hide_default = 0,
                                value.max = stat_value.max
                        hide_default_key = 'armour',
                                overridden = true
                    },
                            end
                },
                         end
             },
                     end
         },
                 end
         {
             end
            args = {'evasion_html'},
            if not overridden then
            func = core.factory.display_value{
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                options = {
                for _, o in ipairs(operations) do
                    [1] = {
                    local stat_ids = stat_def['stats_' .. o]
                        key = 'evasion_html',
                    if stat_ids then
                        before = 'Evasion: ',
                        local total = {min=0, max=0}
                        fmt = '%s',
                        for _, id in ipairs(stat_ids) do
                        hide_default = 0,
                            if tpl_args._stats[id] then
                        hide_default_key = 'evasion',
                                for _, s in ipairs(tpl_args._stats[id]) do
                    },
                                    total.min = total.min + s.min
                },
                                    total.max = total.max + s.max
            },
                                end
         },
                            end
         {
                        end
            args = {'energy_shield_html'},
                         h.stat[o](value, total)
            func = core.factory.display_value{
                    end
                options = {
                end
                    [1] = {
                if stat_def.minimum ~= nil then
                        key = 'energy_shield_html',
                    for _, k in ipairs({'min', 'max'}) do
                        before = 'Energy Shield: ',
                         if value[k] < stat_def.minimum then
                        fmt = '%s',
                            value[k] = stat_def.minimum
                        hide_default = 0,
                        end
                        hide_default_key = 'energy_shield',
                     end
                    },
                end
                },
            end
             },
            value.avg = (value.min + value.max) / 2
        },
 
        -- Misc
            for short_key, range_def in pairs(c.range_map) do
        {
                 tpl_args[stat_def.field .. range_def] = value[short_key]
             args = {'stack_size'},
            end
            func = core.factory.display_value{
           
                options = {
            -- process to HTML to use on list pages or other purposes
                    [1] = {
             h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
                        key = 'stack_size',
         end
                        hide_default = 1,
    end
                        fmt = '%i',
 
                        before = 'Stack Size: ',
    -- Transpose stats into cargo data
                    },
    for _, tbl in ipairs({'_stats', '_random_stats'}) do
                 },
        if tpl_args[tbl] then
             },
             for stat_id, stats in pairs(tpl_args[tbl]) do
         },
                 for _, stat_data in ipairs(stats) do
        -- Essence stuff
                     table.insert(tpl_args._store_data, {
        {
                         _table = 'item_stats',
             args = {'essence_tier'},
                         id = stat_id,
            func = core.factory.display_value{
                         min = stat_data.min,
                 options = {
                         max = stat_data.max,
                     [1] = {
                         avg = stat_data.avg,
                        key = 'essence_tier',
                        mod_id = stat_data.mod and stat_data.mod.id or nil
                        fmt = '%i',
                     })
                        before = 'Essence Tier: ',
                 end
                    },
             end
                 },
         end
             },
    end
        },
end
    },
 
    -- Requirements
function s.process_weapon_dps(tpl_args)
    {
    for key, dps_def in pairs(core.dps_map) do
        {
         local damage = {
            args = {'master', 'master_level_requirement'},
             min = {},
            func = function(tpl_args, frame)
             max = {},
                -- masters have been validated before
        }
                 local data
        for var_type, value in pairs(damage) do
                 for i, rowdata in ipairs(m_game.constants.masters) do
            -- covers the min/max/avg range
                     if tpl_args.master == rowdata.full then
            for short_key, range_def in pairs(c.range_map) do
                        data = rowdata
                 value[short_key] = 0
                        break
                for _, damage_key in ipairs(dps_def.damage_args) do
                     end
                     value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
             h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
         end
    end
end
 
function s.process_gem_variants(tpl_args)
    if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
         return
    end
    local variants = {}
    local title = mw.title.getCurrentTitle()
    local current = {
        page = title.prefixedText,
        name = tpl_args.name,
        id = tpl_args.metadata_id,
        icon = tpl_args.inventory_icon,
        current = true,
    }
    local results
    local tables = {'items', 'skill_gems', 'skill'}
    local fields = {
        'items._pageName=page',
         'items.name=name',
         'items.metadata_id=id',
        'items.inventory_icon=icon'
    }
    local qargs = {
        join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
        orderBy = 'skill.skill_id ASC',
    }
 
    if tpl_args.class_id == 'Active Skill Gem' then
        if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
              
            -- Query base skill gem
             qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                 variants.base = results[1]
             end
         else
            -- Determine base skill gem
             if tpl_args._flags.is_derived then
                 variants.base = {
                     page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
            else
                 variants.base = current
             end
 
            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                 )
                 if title.namespace == 0 then
                     qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                     variants.vaal = results[1]
                 end
                 end
               
                return util.html.poe_color('default', 'Requires ') .. string.format('[[%s|%s %s]]', data.full, data.short_upper, tpl_args.master_level_requirement)
             end
             end
         },
         end
         {
         if variants.base then
             args = function(tpl_args, frame)
            -- Query transfigured skill gem variants
                 if tpl_args.drop_enabled == true then
             qargs.where = string.format(
                     return false
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                 qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                     table.insert(variants.transfigured, row)
                 end
                 end
                return true
            end
            end,
        end
            func = function(tpl_args, frame)
    elseif tpl_args.class_id == 'Support Skill Gem' then
                local span = mw.html.create('span')
        if tpl_args.is_awakened_support_gem then
                span
            variants.awakened = current
                    :attr('class', 'infobox-disabled-drop')
           
                    :wikitext('DROP DISABLED')
             -- Query base support gem
                    :done()
             qargs.where = string.format(
                return tostring(span)
                 [[items.metadata_id IS NOT NULL
             end,
                  AND items.class_id = "Support Skill Gem"
        },
                  AND skill_gems.awakened_variant_id = "%s"
        -- Instead of item level, show drop level if any
                  AND skill_gems.is_awakened_support_gem = false]],
        {
                tpl_args.metadata_id
             args = {'drop_enabled'},
            )
            func = core.factory.display_value{
            if title.namespace == 0 then
                 options = {
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                    [1] = {
             end
                        key = 'drop_level',
             results = m_cargo.query(tables, fields, qargs)
                        fmt = '%i',
             if #results > 0 then
                        before = 'Drop Level: ',
                 variants.base = results[1]
                    },
            end
                    [2] = {
        else
                        key = 'drop_level_maximum',
            variants.base = current
                        hide_default = 100,
 
                        fmt = '%i',
            if tpl_args.awakened_variant_id ~= nil then
                        before = ' / ',
                 -- Query awakened support gem variant
                    },
                 qargs.where = string.format(
                },
                     [[items.metadata_id = "%s"
             },
                      AND items.class_id = "Support Skill Gem"
        },
                      AND skill_gems.is_awakened_support_gem = true]],
        {
                    tpl_args.awakened_variant_id
             args = nil,
                )
             func = function(tpl_args, frame)
                if title.namespace == 0 then
                 local opt = {
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                    [1] = {
                        key = 'required_level_final',
                        hide_default = 1,
                        before = 'Level ',
                        before_color = false,
                    },
                 }
                  
                for _, attr in ipairs(m_game.constants.attributes) do
                     opt[#opt+1] = {
                        key = string.format('required_%s_html', attr['long_lower']),
                        hide_default = 0,
                        hide_default_key = string.format('required_%s', attr['long_lower']),
                        before = ', ',
                        before_color = false,
                        after = ' ' .. attr['short_upper'],
                        after_color = false,
                    }
                 end
                 end
                  
                 results = m_cargo.query(tables, fields, qargs)
                local requirements = core.factory.display_value{options = opt}(tpl_args, frame)
                 if #results > 0 then
               
                     variants.awakened = results[1]
                -- return early
                 if requirements == nil then
                     return
                 end
                 end
               
            end
                requirements = string.gsub(requirements, '^, ', '')
        end
               
    end
                return util.html.poe_color('default', 'Requires ') .. requirements
    tpl_args._variants = {}
            end,
    table.insert(tpl_args._variants, variants.base)
        },
    if variants.transfigured then
     },
        for _, v in ipairs(variants.transfigured) do
     -- Gem description
            table.insert(tpl_args._variants, v)
    {
        end
        css_class = '-textwrap tc -gemdesc',
    end
        {
     table.insert(tpl_args._variants, variants.vaal)
            args = {'gem_description'},
     table.insert(tpl_args._variants, variants.awakened)
            func = core.factory.display_value_only('gem_description'),
end
         },
 
     },
function s.get_categories(tpl_args)
     -- Gem Quality Stats
    local cats = {}
    {
    if tpl_args._flags.is_prophecy then
         css_class = '-textwrap tc -mod',
        table.insert(cats, i18n.categories.prophecies)
         {
    elseif tpl_args._flags.is_blight_item then
            args = {'quality_stat_text'},
         table.insert(cats, i18n.categories.oils)
            func = function(tpl_args, frame)
     elseif tpl_args._flags.is_talisman then
                lines = {}
        table.insert(cats, i18n.categories.talismans)
                lines[#lines+1] = util.html.poe_color('default', 'Per 1% Quality:')
     elseif tpl_args._flags.is_essence then
                lines[#lines+1] = tpl_args.quality_stat_text
         table.insert(cats, i18n.categories.essences)
               
    elseif tpl_args._flags.is_fossil then
                return table.concat(lines, '<br>')
         table.insert(cats, i18n.categories.fossils)
            end,
    elseif tpl_args._flags.is_scarab then
         },
        table.insert(cats, i18n.categories.scarabs)
     },
    elseif tpl_args._flags.is_tattoo then
     -- Gem Implicit Stats
        table.insert(cats, i18n.categories.tattoos)
    {
    elseif tpl_args._flags.is_delirium_orb then
        css_class = '-textwrap tc -mod',
         table.insert(cats, i18n.categories.delirium_orbs)
         {
     elseif tpl_args._flags.is_catalyst then
            args = function(tpl_args, frame)
        table.insert(cats, i18n.categories.catalysts)
                return core.class_groups.gems.keys[tpl_args.class] and tpl_args.stat_text
     elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
            end,
         table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
             func = function(tpl_args, frame)
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
                lines = {}
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
                lines[#lines+1] = tpl_args.stat_text
             table.insert(cats, v)
                if tpl_args.gem_tags:contains('Vaal') then
        end
                    lines[#lines+1] = util.html.poe_color('corrupted', 'Corrupted')  
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
                end
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
                 return table.concat(lines, '<br>')
            if tpl_args.rarity_id == 'unique' then
             end,
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
         },
            else
     },
                 table.insert(cats, v)
     -- Implicit Stats
             end
     {
         end
        css_class = '-textwrap tc -mod',
     else
         func = function(tpl_args, frame)
        table.insert(cats, tpl_args.class)
            if tpl_args.implicit_stat_text ~= '' then
     end
                return {tpl_args.implicit_stat_text}
      
            else
    if tpl_args._flags.is_derived then
                return {}
         table.insert(cats, i18n.categories.derived_items)
            end
    else
         end,
         table.insert(cats, i18n.categories.base_items)
     },
     end
    -- Stats
 
     {
     for _, tag in ipairs(tpl_args.acquisition_tags) do
        css_class = '-textwrap tc -mod',
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
        func = function(tpl_args, frame)
            table.insert(cats, cfg.acquisition_tags[tag].cat)
            if tpl_args.explicit_stat_text ~= '' then
         end
                return {tpl_args.explicit_stat_text}
     end
            else
      
                return {}
     for _, attr in ipairs(m_game.constants.attribute_order) do
            end
         if tpl_args[attr .. '_percent'] then
         end,
             table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
     },
         end
     -- Experience
     end
     {
      
         {
     if cfg.class_groups.gems.keys[tpl_args.class_id] then
            args = {'experience'},
         for _, tag in ipairs(tpl_args.gem_tags) do
             func = core.factory.display_value{
             table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
                key = 'experience',
         end
                options = {
     end
                    [1] = {
 
                        fmt = '%i',
     if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
                    },
        table.insert(cats, i18n.categories.implicit_modifier_override)
                },
     end
            },
   
         },
    if #tpl_args.alternate_art_inventory_icons > 0 then
     },
         table.insert(cats, i18n.categories.alternate_artwork)
     -- Description (currency, doodads)
    end
     {
 
         css_class = '-textwrap tc -mod',
    if tpl_args._flags.has_legacy_drop_areas == true then
        {
        mw.log('IDs of legacy map areas used in drop_areas:')
             args = {'description'},
        mw.logObject(tpl_args._legacy_drop_areas)
            func = core.factory.display_value_only('description'),
         table.insert(cats, i18n.categories.legacy_drop_areas)
         },
     end
     },
      
     -- Variations (for doodads)
     if tpl_args.release_version == nil then
     {
         table.insert(cats, i18n.categories.missing_release_version)
      css_class = 'tc -mod',
    end
         {
   
            args = {'variation_count'},
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
            func = function(tpl_args, frame)
         table.insert(cats, i18n.categories.improper_modifiers)
                local txt
     end
                if tpl_args.variation_count == 1 then
      
                    txt = 'Variation'
     for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
                else
        if tpl_args._flags[k] then
                    txt = 'Variations'
             table.insert(cats, i18n.categories[k])
                end
         end
                return string.format('%i %s', tpl_args.variation_count, txt)
     end
            end,
 
         },
     if tpl_args.disable_automatic_recipes == true then
     },
         table.insert(cats, i18n.categories.automatic_recipes_disabled)
     -- Flavour Text
    end
     {
 
         css_class = '-textwrap tc -flavour',
    if tpl_args._flags.uses_deprecated_parameters == true then
        {
        mw.log('Deprecated parameters used:')
            args = {'flavour_text'},
        mw.logObject(tpl_args._deprecated_args)
            func = core.factory.display_value_only('flavour_text'),
         table.insert(cats, i18n.categories.deprecated_parameters)
         },
     end
     },
 
     -- Prophecy text
     if tpl_args._flags.has_deprecated_skill_parameters then
     {
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
        css_class = '-textwrap tc -value',
     end
        {
    return cats
            args = {'prediction_text'},
end
             func = core.factory.display_value_only('prediction_text'),
 
         },
-- ----------------------------------------------------------------------------
     },
-- Main functions
    -- Help text
-- ----------------------------------------------------------------------------
     {
 
         css_class = '-textwrap tc -help',
local function _main(tpl_args)
        {
    local t = os.clock() -- Start time (for logging)
            args = {'help_text'},
    tpl_args._flags = {}
            func = core.factory.display_value_only('help_text'),
    tpl_args._store_data = {}
         },
    tpl_args._errors = {}
     },
   
     -- Cost (i.e. vendor costs)
    -- Item configuration
     {
    tpl_args._item_config = s.get_item_config(tpl_args)
        --css_class = '',
 
        {
    -- Add table names to core.map and append range fields.
            args = {'master_favour_cost'},
    h.append_schema(tpl_args, tpl_args._item_config.tables)
            func = core.factory.display_value{
   
                options = {
    -- Using general purpose function to handle release and removal versions
                    [1] = {
    m_util.args.version(tpl_args)
                        key = 'master_favour_cost',
 
                        before = 'Favour cost: ',
    -- Assume this is meant to be a derived item if any base item parameters are set
                        color = 'currency',
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
                    },
   
                },
    -- Must validate some argument early. It is required for future things
            },
    h.process_arguments(tpl_args, tpl_args._item_config.args)
        },
 
        {
    -- Base item
            args = {'seal_cost_normal', 'seal_cost_cruel', 'seal_cost_merciless'},
    s.process_base_item(tpl_args)
            func = core.factory.display_value{
 
                options = {
    -- Process arguments that require a particular flag to be set
                    [1] = {
    -- Used for subsets of item classes that have additional fields
                        key = 'seal_cost_normal',
    for k, v in pairs(cfg.flagged_args) do
                        before = 'Seal cost: <br>',
        if tpl_args._flags[k] then
                        fmt = '%dx/',
            h.process_arguments(tpl_args, v.args)
                        color = 'currency',
        end
                    },
    end
                    [2] = {
   
                        key = 'seal_cost_cruel',
    -- Mods
                        fmt = '%dx/',
    s.process_mods(tpl_args)
                        color = 'currency',
 
                    },
    -- Stats
                    [3] = {
    s.process_stats(tpl_args)
                        key = 'seal_cost_merciless',
 
                        fmt = '%dx',
    -- Calculate and handle weapon dps
                        color = 'currency',
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
                        after = function (tpl_args, frame)  
        s.process_weapon_dps(tpl_args)
                            -- direct call will mess up tpl_args
    end
                            return p.item_link{item_name_exact='Silver Coin'}
 
                        end,
    -- Skill gems
                    },
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
                },
         h.process_skill_data(tpl_args)
            },
    end
         },
   
     },
    -- Late argument processing
}
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
      
    -- Recipes
    h.process_recipes(tpl_args)
   
    -- Quest reward info
    s.process_quest_rewards(tpl_args)


core.item_link_params = {'name', 'inventory_icon', 'html'}
    -- Gem variants
core.item_link_broken_cat = '[[Category:Pages with broken item links]]'
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        s.process_gem_variants(tpl_args)
    end
   
    -- ------------------------------------------------------------------------
    -- Infobox handling
    -- ------------------------------------------------------------------------


core.result = {}
    --
    -- Tabs
    --
 
    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then   
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end
 
    --
    -- Primary infobox
    --


core.result.generic_item = {
    tpl_args._infobox_container = 'infobox'
     {
     local infobox = h.make_main_infobox(tpl_args)
        arg = 'base_item',
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        header = 'Base Item',
         infobox:tag('span')
        properties = {'Has base item', 'Has base item wiki page'},
            :addClass('images')
         display = function(tr, data)
            :wikitext(string.format(
            tr
                '[[%s|%sx%spx]]',
                :tag('td')
                tpl_args.inventory_icon,
                    :attr('data-sort-value', data['Has base item'])
                cfg.image_size_full * tpl_args.size_x,
                    :wikitext(string.format('[[%s|%s]]', data['Has base item'], data['Has base item wiki page']))
                cfg.image_size_full * tpl_args.size_y
        end,
            ))
        order = 1000,
     end
    },
     tpl_args.infobox_html = tostring(infobox)
    {
      
        arg = 'essence',
     --
        header = 'Essence<br>Tier',
     -- Secondary infobox
        properties = {'Has essence tier'},
     --
        display = h.tbl.display.factory.value{},
      
        order = 2000,
     local extra_infobox = mw.html.create('div')
    },
         :addClass('item-box -' .. tpl_args.frame_type)
    {
     h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
        arg = 'drop_level',
     tpl_args.metabox_html = tostring(extra_infobox)
        header = 'Drop<br>Level',
   
        properties = {'Has drop level'},
    --
        display = h.tbl.display.factory.value{},
     -- Output
        order = 3000,
     --
     },
   
     {
    local container = mw.html.create('div')
        arg = 'stack_size',
         :addClass('infobox-page-container')
        header = 'Stack<br>Size',
     if tabs then
        properties = {'Has stack size'},
         container:node(tabs)
        display = h.tbl.display.factory.value{},
     end
        order = 4000,
     container
    },
         :node(infobox)
    {
         :node(extra_infobox)
        arg = 'stack_size_currency_tab',
        header = util.html.abbr('Tab<br>Stack<br>Size', 'Stack size in the currency stash tab'),
        properties = {'Has currency tab stack size'},
        display = h.tbl.display.factory.value{},
        order = 4001,
     },
     {
        arg = 'level',
        header = m_game.level_requirement.icon,
        properties = {'Has level requirement'},
        display = h.tbl.display.factory.value{},
        order = 5000,
     },
     {
        arg = 'str',
        header = m_game.constants.attributes[1].icon,
        properties = {'Has strength percentage'},
        display = h.tbl.display.factory.value{},
        order = 5100,
    },
    {
        arg = 'dex',
        header = m_game.constants.attributes[2].icon,
        properties = {'Has dexterity percentage'},
        display = h.tbl.display.factory.value{},
        order = 5200,
     },
     {
        arg = 'int',
        header = m_game.constants.attributes[3].icon,
        properties = {'Has intelligence percentage'},
        display = h.tbl.display.factory.value{},
        order = 5300,
    },
    {
        arg = 'ar',
        header = util.html.abbr('AR', 'Armour'),
         properties = h.tbl.range_properties('armour'),
        display = h.tbl.display.factory.range{property='armour'},
        order = 6000,
     },
    {
        arg = 'ev',
        header = util.html.abbr('EV', 'Evasion Rating'),
        properties = h.tbl.range_properties('evasion'),
        display = h.tbl.display.factory.range{property='evasion'},
        order = 6001,
     },
    {
        arg = 'es',
        header = util.html.abbr('ES', 'Energy Shield'),
        properties = h.tbl.range_properties('energy shield'),
        display = h.tbl.display.factory.range{property='energy shield'},
        order = 6002,
     },
     {
        arg = 'block',
        header = util.html.abbr('Block', 'Chance to Block'),
         properties = h.tbl.range_properties('block'),
        display = h.tbl.display.factory.range{property='block'},
        order = 6003,
     },
    {
         arg = 'physical_damage_min',
        header = util.html.abbr('Min', 'Local minimum weapon damage'),
        properties = h.tbl.range_properties('minimum physical damage'),
        display = h.tbl.display.factory.range{property='minimum physical damage'},
        order = 7000,
     },
     {
         arg = 'physical_damage_max',
        header = util.html.abbr('Max', 'Local maximum weapon damage'),
         properties = h.tbl.range_properties('maximum physical damage'),
        display = h.tbl.display.factory.range{property='maximum physical damage'},
        order = 7001,
          
          
     },
     -- skill_screenshot is set in skill module
     {
     if tpl_args.skill_screenshot then
         arg = 'weapon',
         container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
        header = util.html.abbr('Damage', 'Colour coded damage'),
    end
        properties = {'Has damage HTML', 'Has average damage'},
   
        display = function (tr, data)
    local out = tostring(container)
            tr
   
                :tag('td')
    local cats = s.get_categories(tpl_args)
                    :attr('data-sort-value', data['Has average damage'])
   
                    :wikitext(data['Has damage HTML'])
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
        end,
      
        order = 8000,
     --
     },
    --  Misc
     {
    --
        arg = 'weapon',
   
         header = util.html.abbr('APS', 'Attacks per second'),
    -- Also show the infobox for areas right away for maps, since they're both on the same page
         properties = h.tbl.range_properties('attack speed'),
    local query_id
         display = h.tbl.display.factory.range{property='attack speed'},
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        order = 8001,
         query_id = tpl_args.map_area_id
    },
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
    {
         query_id = tpl_args.unique_map_area_id
        arg = 'weapon',
    end
        header = util.html.abbr('Crit', 'Local weapon critical strike'),
 
        properties = h.tbl.range_properties('critical strike chance'),
    if query_id then
        display = h.tbl.display.factory.range{property='critical strike chance'},
         out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
        order = 8002,
    end
     },
   
    {
     -- ------------------------------------------------------------------------
        arg = 'flask_life',
    -- Store cargo data
        header = util.html.abbr('Life', 'Life regenerated over the flask duration'),
    -- ------------------------------------------------------------------------
        properties = h.tbl.range_properties('flask life recovery'),
 
        display = h.tbl.display.factory.range{property='flask life recovery'},
     -- Store the infobox so it can be accessed with ease on other pages
        order = 9000,
     tpl_args._infobox_container = 'inline'
    },
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))
    {
 
        arg = 'flask_mana',
    -- Map argument values for cargo storage
        header = util.html.abbr('Mana', 'Mana regenerated over the flask duration'),
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        properties = h.tbl.range_properties('flask mana recovery'),
        tpl_args._store_data[table_name] = {
        display = h.tbl.display.factory.range{property='flask mana recovery'},
            _table = table_name,
        order = 9001,
         }
     },
     end
     {
     for k, v in pairs(tpl_args) do
        arg = 'flask',
         local arg_def = core.map[k]
        header = 'Duration',
         if arg_def ~= nil then
        properties = h.tbl.range_properties('flask duration'),
            if arg_def.table ~= nil and arg_def.field ~= nil then
        display = h.tbl.display.factory.range{property='flask duration'},
                if arg_def.type == 'Integer' then
         order = 9002,
                    v = tonumber(string.format("%.0f", v))
     },
                    if v ~= tpl_args[k] then
     {
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
        arg = 'flask',
                    end
        header = util.html.abbr('Usage', 'Number of charges consumed on use'),
                end
         properties = h.tbl.range_properties('flask charges per use'),
                if tpl_args._store_data[arg_def.table] == nil then
         display = h.tbl.display.factory.range{property='flask charges per use'},
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
        order = 9003,
                end
    },
                 if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
    {
                     error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
        arg = 'flask',
                end
        header = util.html.abbr('Capacity', 'Maximum number of flask charges held'),
                tpl_args._store_data[arg_def.table][arg_def.field] = v
        properties = h.tbl.range_properties('maximum flask charges'),
            elseif arg_def.table ~= nil and arg_def.field == nil then
        display = h.tbl.display.factory.range{property='maximum flask charges'},
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
        order = 9004,
            elseif arg_def.table == nil and arg_def.field ~= nil then
    },
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
    {
            end
        arg = 'jewel_radius',
         end
        header = 'Radius',
     end
        properties = {'Has jewel radius', 'Has jewel radius HTML'},
      
        display = function (tr, data)
    -- Don't store cargo data in testing mode
            tr
    if not tpl_args.test then
                 :tag('td')
         local attach = {}
                     :attr('data-sort-value', data['Has jewel radius'])
         for _, data in pairs(tpl_args._store_data) do
                    :wikitext(data['Has jewel radius HTML'])
            if attach[data._table] == nil then
        end,
                local i = 0
        order = 10000,
                for _, _ in pairs(data) do
    },
                    i = i + 1
    {
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
        arg = 'map_tier',
                    if i > 1 then
        header = 'Map<br>Tier',
                        attach[data._table] = true
        properties = {'Has map tier'},
                        -- One of the purposes of attaching is to facilitate table recreation.
        display = h.tbl.display.factory.value{},
                        -- Unfortunately, the Cargo extension's table recreation tool is
        order = 11000,
                        -- very slow and often fails to rebuild the entire table.
    },
                        mw.getCurrentFrame():expandTemplate{
    {
                            title = string.format(i18n.templates.cargo_attach, data._table),
        arg = 'map_level',
                            args = {}
        header = 'Map<br>Level',
                        }
        properties = {'Has map area level'},
                        break
        display = h.tbl.display.factory.value{},
                    end
         order = 11010,
                end
     },
            end
     {
            m_cargo.store(data, {
        arg = 'map_guild_character',
                debug = tpl_args.debug,
        header = util.html.abbr('Char', 'Character for the guild tag'),
                sep = {
         properties = {'Has map guild character'},
                    name_list = '�',
         display = h.tbl.display.factory.value{colour='value'},
                },
        order = 11020,
            })
    },
         end
    {
        arg = 'buff',
        header = 'Buff Effects',
        properties = {'Has buff stat text'},
        display = h.tbl.display.factory.value{colour='mod'},
        order = 12000,
    },
    {
        arg = 'stat',
        header = 'Stats',
        properties = {'Has stat text'},
        display = h.tbl.display.factory.value{colour='mod'},
        order = 12001,
    },
    {
         arg = 'description',
        header = 'Effect(s)',
        properties = {'Has description'},
        display = h.tbl.display.factory.value{colour='mod'},
        order = 12002,
    },
    {
        arg = 'flavour_text',
        header = 'Flavour Text',
        properties = {'Has flavour text'},
        display = h.tbl.display.factory.value{colour='flavour'},
        order = 12003,
    },
    {
        arg = 'help_text',
        header = 'Help Text',
        properties = {'Has help text'},
        display = h.tbl.display.factory.value{colour='help'},
        order = 12004,
    },
    {
        arg = 'buff_icon',
        header = 'Buff Icon',
        properties = {'Has buff icon'},
        display = function (tr, data, properties)
            tr
                :tag('td')
                    :wikitext(string.format('[[%s]]', data['Has buff icon']))
        end,
        order = 13000,
    },
}
 
for i, data in ipairs(core.dps_map) do
    table.insert(core.result.generic_item, {
        arg = data.name,
        header = data.label,
        properties = h.tbl.range_properties(data.property),
        display = h.tbl.display.factory.range{property=data.property},
        order = 8100+i,
    })
end
 
core.result.skill_gem = {
    {
        arg = 'icon',
        header = util.html.abbr('L', 'Support gem letter.'),
        property = 'Has support gem letter HTML',
        properties = {'Has support gem letter HTML'},
        cast = nil,
        display = h.tbl.display.na_or_val,
    },
    {
        arg = 'skill_icon',
        header = 'Icon',
        property = 'Has skill gem icon',
        properties = {'Has skill gem icon'},
        cast = nil,
        display = h.tbl.display.wikilink,
    },
    {
        arg = 'description',
        header = 'Description',
        property = 'Has description',
        properties = {'Has description'},
        cast = nil,
        display = h.tbl.display.na_or_val,
    },
    {
        arg = 'level',
        header = m_game.level_requirement.icon,
        property = 'Has level requirement',
        properties = {'Has level requirement'},
        cast = tonumber,
        display = h.tbl.display.na_or_val,
    },
    {
        arg = 'crit',
        header = util.html.abbr('Crit', 'Critical Strike Chance'),
        property = 'Has critical strike chance',
        properties = {'Has critical strike chance'},
        cast = tonumber,
        display = h.tbl.display.percent,
    },
    {
        arg = 'cast_time',
        header = util.html.abbr('Cast<br>Time', 'Casting time of the skill in seconds'),
        property = 'Has cast time',
        properties = {'Has cast time'},
        cast = tonumber,
        display = h.tbl.display.seconds,
    },
    {
        arg = 'dmgeff',
        header = util.html.abbr('Dmg.<br>Eff.', 'Damage Effectiveness'),
        property = 'Has damage effectiveness',
        properties = {'Has damage effectiveness'},
        cast = tonumber,
        display = h.tbl.display.percent,
    },
    {
        arg = 'mcm',
        header = util.html.abbr('MCM', 'Mana cost multiplier - missing values indicate it changes on gem level'),
        property = 'Has mana multiplier',
        properties = {'Has mana multiplier'},
        cast = tonumber,
        display = h.tbl.display.percent,
    },
    {
        arg = 'mana',
        header = util.html.abbr('Mana', 'Mana cost'),
        property = 'Has mana cost',
        properties = {'Has mana cost'},
        cast = tonumber,
        display = function (tr, value, data)
            local appendix = ''
            if data['?Has percentage mana cost'] then
                appendix = appendix .. '%'
            end
            if data['?Has reservation mana cost'] then
                appendix = appendix .. ' ' .. util.html.abbr('R', 'reserves mana')
            end
           
            local str
           
            if value ~= nil then
                str = string.format('%d', value) .. appendix
            end
            return h.na_or_val(tr, str)
        end,
    },
    {
        arg = 'vaal',
        header = util.html.abbr('Souls', 'Vaal souls requirement in Normal/Cruel/Merciless difficulty'),
        property = 'Has vaal souls requirement',
        properties = {'Has vaal souls requirement'},
        cast = tonumber,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, function (value)
                return string.format('%d / %d / %d', value, value*1.5, value*2)
            end)
        end,
    },
    {
        arg = 'vaal',
        header = util.html.abbr('Uses', 'Maximum number of stored uses'),
        property = 'Has vaal stored uses',
        properties = {'Has vaal stored uses'},
        cast = tonumber,
        display = h.tbl.display.na_or_val,
    },
    {
        arg = 'radius',
        header = util.html.abbr('R1', 'Primary radius'),
        property = 'Has primary radius',
        properties = {'Has primary radius'},
        cast = tonumber,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has primary radius description', tbl=data})
        end,
    },
    {
        arg = 'radius',
        header = util.html.abbr('R2', 'Secondary radius'),
        property = 'Has secondary radius',
        properties = {'Has secondary radius'},
        cast = tonumber,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has secondary radius description', tbl=data})
        end,
    },
    {
        arg = 'radius',
        header = util.html.abbr('R3', 'Tertiary radius'),
        property = 'Has tertiary radius',
        properties = {'Has tertiary radius'},
        cast = tonumber,
        display = function (tr, value, data)
            return h.na_or_val(tr, value, core.factory.descriptor_value{key='?Has tertiary radius description', tbl=data})
        end,
    },
}
 
for i, attr in ipairs(m_game.constants.attributes) do
    table.insert(core.result.generic_item, 7, {
        arg = attr.short_lower,
        header = attr.icon,
        properties = h.tbl.range_properties(string.format('%s requirement', attr.long_lower)),
        display = h.tbl.display.factory.range{property=string.format('%s requirement', attr.long_lower)},
        order = 5000+i,
    })
    table.insert(core.result.skill_gem, 3, {
        arg = attr.short_lower,
        header = attr.icon,
        property = string.format('Has %s percentage', attr.long_lower),
        cast = tonumber,
        display = function (tr, value)
            return h.na_or_val(tr, value, function (value)
                return '[[File:Yes.png|yes|link=]]'
            end)
        end,
    })
end
 
-- ----------------------------------------------------------------------------
-- Page views
-- ----------------------------------------------------------------------------
 
--
-- Template:Item
--
 
function p.itembox (frame)
    --
    -- Args/Frame
    --
    local t = os.clock()
   
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = util.misc.get_frame(frame)
   
    --
    -- Shared args
    --
   
    core.build_item_classes()
   
    tpl_args._total_args = {}
    tpl_args._base_item_args = {}
    tpl_args._mods = {}
    tpl_args._stats = {}
    tpl_args._explicit_stats = {}
    tpl_args._subobjects = {}
    tpl_args._properties = {}
   
    -- Using general purpose function to handle release and removal versions
    util.args.version(tpl_args, {frame=frame, set_properties=true})
   
    -- Must validate some argument early. It is required for future things
    core.process_arguments(tpl_args, frame, {array=core.default_args})
    core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class].args})
   
    -- set defaults
   
    for k, v in pairs(core.item_classes[tpl_args.class].defaults) do
        if tpl_args[k] == nil then
            tpl_args[k] = v
        end
    end
   
    -- Base Item
 
    core.process_base_item(tpl_args, frame)
   
    -- Prophecy special snowflake
    if tpl_args.base_item == 'Prophecy' then
        err = core.process_arguments(tpl_args, frame, {array=core.prophecy_args})
        if err then
            return err
        end
       
        tpl_args.inventory_icon = 'File:Prophecy inventory icon.png'
    end
   
    -- Mods
 
    for _, k in ipairs({'implicit', 'explicit'}) do
        local success = true
        local i = 1
        while success do
            success = core.validate_mod(tpl_args, frame, {key=k, i=i})
            i = i + 1
        end
    end
   
    core.process_smw_mods(tpl_args, frame)
       
    -- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    util.args.stats(tpl_args, {prefix='extra_'})
    for _, stat in ipairs(tpl_args.extra_stats) do
        if stat.value ~= nil then
            stat.min = stat.value
            stat.max = stat.value
            stat.avg = stat.value
        end
        h.stats_update(tpl_args, stat.id, stat, nil, '_stats')
        h.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
    end
 
    -- Transpose stats into subobjects
    for id, data in pairs(tpl_args._stats) do
        tpl_args._subobjects[id] = {
            ['Has stat id'] = id,
            ['Has minimum stat value'] = data.min,
            ['Has maximum stat value'] = data.max,
            ['Has average stat value'] = data.avg,
        }
    end
    for id, data in pairs(tpl_args._explicit_stats) do
        tpl_args._subobjects['explicit_' .. id] = {
            ['Has explicit stat id'] = id,
            ['Has minimum stat value'] = data.min,
            ['Has maximum stat value'] = data.max,
            ['Has average stat value'] = data.avg,
        }
    end
   
    -- Handle extra stats (for gems)
   
    if core.class_groups.gems.keys[tpl_args.class] then
        m_skill.skill(frame, tpl_args)
    end
   
    --
    -- Handle local stats increases/reductions/additions
    --
   
    local skip = {}
    -- override attributes for tabula rasa
    if tpl_args._stats.local_unique_tabula_rasa_no_requirement_or_energy_shield ~= nil and tpl_args._stats.local_unique_tabula_rasa_no_requirement_or_energy_shield.min == 1 then
        tpl_args.required_level_final = 1
    end
   
    -- general stats
    for k, data in pairs(core.stat_map) do
        local value = tpl_args[k]
        if value == nil and data.default ~= nil then
            value = data.default
            tpl_args[k] = data.default
        end
       
        if value ~= nil and skip[k] == nil then
            value = {min=value, max=value, base=value}
            -- If stats are overriden we scan save some CPU time here
            local overridden = false
            if data.stats_override ~= nil then
                for stat_id, override_value in pairs(data.stats_override) do
                    local stat_value = tpl_args._stats[stat_id]
                    if stat_value ~= nil then
                        -- Use the value of stat
                        if override_value == true then
                            value.min = stat_value.min
                            value.max = stat_value.max
                            overridden = true
                        elseif stat_value ~= 0 then
                            value.min = override_value.min
                            value.max = override_value.max
                            overridden = true
                        end
                    end
                end
          end
               
          if overridden == false then
                -- The simple cases; this must be using ipairs as "add" must apply before
                for _, operator in ipairs({'add', 'more'}) do
                    local st = data['stats_' .. operator]
                    if st ~= nil then
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                h.stat[operator](value, tpl_args._stats[statid])
                            end
                        end
                    end
                end
               
                -- For increased stats we need to add them up first
                for stat_key, stat_func in pairs({increased=h.stat.more, increased_inverse=h.stat.more_inverse}) do
                    local st = data['stats_' .. stat_key]
                    if st ~= nil then
                        local total_increase = {min=0, max=0}
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                for var, current_value in pairs(total_increase) do
                                    total_increase[var] = current_value + tpl_args._stats[statid][var]
                                end
                            end
                        end
                        stat_func(value, total_increase)
                    end
                end
               
                if data.minimum ~= nil then
                    for _, key in ipairs({'min', 'max'}) do
                        if value[key] < data.minimum then
                            value[key] = data.minimum
                        end
                    end
                end
            else
 
            end
           
            value.avg = (value.min + value.max) / 2
           
            -- don't add the properties unless we need to
            if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
                for short_key, range_data in pairs(h.range_map) do
                    tpl_args._properties[data.property .. range_data.property] = value[short_key]
                end
               
                -- process to HTML to use on list pages or other purposes
                h.handle_range_args(tpl_args, frame, k, data.property, value, data.html_fmt_options or {})
            end
           
            for short_key, range_data in pairs(h.range_map) do
                tpl_args[k .. range_data.var] = value[short_key]
            end
        end
    end
 
    -- calculate and handle weapon dps
    if core.class_groups.weapons.keys[tpl_args.class] then
        for _, data in ipairs(core.dps_map) do
            local damage = {
                min = {},
                max = {},
            }
       
            for var_type, value in pairs(damage) do
                -- covers the min/max/avg range
                for short_key, range_data in pairs(h.range_map) do
                    value[short_key] = 0
                    for _, damage_key in ipairs(data.damage_args) do
                        value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
                    end
                end
            end
 
            local value = {}
            for short_key, range_data in pairs(h.range_map) do
                local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
                value[short_key] = result
                tpl_args[string.format('%s%s', data.name, range_data.var)] = result
                -- It will set the property, even if 0.
                -- Not sure if it is better to not set it, but on the other hand this way it can be queried for having no dps of a particular type
                tpl_args._properties[string.format('Has %s%s', data.property, range_data.property)] = result
            end
           
            if value.avg > 0 then
                h.handle_range_args(tpl_args, frame, data.name, 'Has ' .. data.property, value, data.html_fmt_options or {})
            end
        end
    end
   
    -- late processing
    core.process_arguments(tpl_args, frame, {array=core.late_args})
    core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class].late_args})
   
    -- Setting semantic properties Part 1 (base values)
   
    local val
   
    for _, k in ipairs(tpl_args._total_args) do
        local prop = core.map[k].property
        val = tpl_args[k]
        if val == nil then
        elseif prop == nil then
            --mw.logObject(k)
        else
            tpl_args._properties[prop] = val
        end
    end
   
    util.smw.set(frame, tpl_args._properties)
   
    -- Subobjects
    local command
    for key, properties in pairs(tpl_args._subobjects) do
        command = ''
        if type(key) ~= 'number' then
            command = key
        end
        util.smw.subobject(frame, command, properties)
    end
   
    -- ------------------------------------------------------------------------
    -- Infobox handling
    -- ------------------------------------------------------------------------
   
    tpl_args._properties = {}
    local container = mw.html.create('span')
        :attr( 'class', 'item-box -' .. tpl_args.frame_type)
   
    if tpl_args.class == 'Divination Card' then
        --TODO div card code
        container
            :tag('span')
                :attr( 'class', 'divicard-wrapper')
                :tag('span')
                    :attr('class', 'divicard-art')
                    :wikitext( '[[File:' .. tpl_args.card_art .. '|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-frame')
                    :wikitext( '[[File:Divination card frame.png|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-header')
                    :wikitext(tpl_args.name)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-stack')
                    :wikitext(tpl_args.stack_size)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-reward')
                    :tag('span')
                        :wikitext(tpl_args.card_reward)
                        :done()
                    :done()
                :tag('span')
                    :attr('class', 'divicard-flavour text-color -flavour')
                    :tag('span')
                        :wikitext(tpl_args.flavour_text)
                        :done()
                    :done()
                :done()
        --TODO Extras?
    else
        local header_css
        if tpl_args.base_item and tpl_args.rarity ~= 'Normal' then
            line_type = 'double'
        else
            line_type = 'single'
        end
       
        local name_line = tpl_args.name
        if tpl_args.base_item and tpl_args.base_item ~= 'Prophecy' then
            name_line = name_line .. '<br>' .. tpl_args.base_item
        end
       
        container
            :tag('span')
                :attr( 'class', 'header -' .. line_type )
:wikitext( name_line )
            :done()
           
        local grpcont
        local valid
        local statcont = container:tag('span')
        statcont
            :attr('class', 'item-stats')
            :done()
           
        for _, group in ipairs(core.display_groups) do
            grpcont = {}
            if group.func == nil then
                for _, disp in ipairs(group) do
                    valid = true
                    -- No args to verify which means always valid
                    if disp.args == nil then
                    elseif type(disp.args) == 'table' then
                        for _, key in ipairs(disp.args) do
                            if tpl_args[key] == nil then
                                valid = false
                                break
                            end
                        end
                    elseif type(disp.args) == 'function' then
                        valid = disp.args(tpl_args, frame)
                    end
                    if valid then
                        grpcont[#grpcont+1] = disp.func(tpl_args, frame)
                    end
                end
            else
                grpcont = group.func(tpl_args, frame)
            end
           
            if #grpcont > 0 then
                statcont
                    :tag('span')
                    :attr('class', 'group ' .. (group.css_class or ''))
                    :wikitext(table.concat(grpcont, '<br>'))
                    :done()
            end
        end
    end
   
    frame:callParserFunction('#set:', tpl_args._properties)
   
    if tpl_args.gem_icon ~= nil then
        container:wikitext(string.format('[[%s]]', tpl_args.gem_icon))
    end
   
    -- Store the infobox so it can be accessed with ease on other pages
    frame:callParserFunction('#set:', {['Has infobox HTML'] = tostring(container)})
   
    if tpl_args.inventory_icon ~= nil then
        container:wikitext(string.format('[[%s]]', tpl_args.inventory_icon))
    end
   
    local infobox = mw.html.create('span')
    infobox
        :attr('class', 'infobox-page-container')
        :node(container)
       
    if tpl_args.skill_screenshot then
        infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
   
    local out = tostring(infobox)
   
    -- ------------------------------------------------------------------------
    -- Category handling
    -- ------------------------------------------------------------------------
   
    local cats = {}
    if tpl_args.rarity == 'Unique' then
        cats[#cats+1] = 'Unique ' .. tpl_args.class
    elseif tpl_args.base_item == 'Prophecy' then
        cats[#cats+1] = 'Prophecies'
    else
        cats[#cats+1] = tpl_args.class
    end
   
    for _, attr in ipairs(m_game.constants.attributes) do
        if tpl_args[attr.long_lower .. '_percent'] then
            cats[#cats+1] = string.format('%s %s', attr.long_upper, tpl_args.class)
        end
    end
   
    local suffix
    if tpl_args.class == 'Active Skill Gems' or tpl_args.class == 'Support Skill Gems' then
        suffix = ' (gem tag)'
    end
    if suffix ~= nil then
        for _, tag in ipairs(tpl_args.gem_tags) do
            cats[#cats+1] = tag .. suffix
        end
    end
   
    if #tpl_args.alternate_art_inventory_icons > 0 then
        cats[#cats+1] = 'Items with alternate artwork'
    end
   
    -- TODO: add maintenance categories
   
    if tpl_args.release_version == nil then
        cats[#cats+1] = 'Items without a release version'
    end
   
    out = out .. util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
   
    --
    --
    --
 
    mw.logObject(os.clock() - t)
   
    return out
end
 
--
-- Template:Item link & Template:Sl
--
 
function p.item_link (frame)
    --
    -- Args/Frame
    --
   
    local tpl_args = getArgs(frame, {
        parentFirst = true,
        removeBlanks = false,
    })
    frame = util.misc.get_frame(frame)
   
    -- Backwards compability
    tpl_args.item_name = tpl_args.item_name or tpl_args[1]
    if tpl_args.item_name ~= nil then
        tpl_args.item_name = mw.ustring.lower(tpl_args.item_name)
    end
    tpl_args.name = tpl_args.name or tpl_args[2]
   
    if util.table.has_all_value(tpl_args, {'page', 'item_name', 'item_name_exact'}) then
        error('page, item_name or item_name_exact must be specified')
    end
   
    tpl_args.large = util.cast.boolean(tpl_args.large)
   
    local img
    local result
   
    if util.table.has_one_value(tpl_args, core.item_link_params, nil) or tpl_args.item_name ~= nil then
        local query = {}
       
        if tpl_args.page ~= nil then
            -- TODO returns the result even if the + format is specified.
            query[#query+1] = string.format('[[%s]]', tpl_args.page)
        else
            if tpl_args.item_name ~= nil then
                query[#query+1] = string.format('[[Has lowercase names::%s]]', tpl_args.item_name)
            elseif tpl_args.item_name_exact ~= nil then
                query[#query+1] = string.format('[[Has name::%s]]', tpl_args.item_name_exact)
            end
           
            query[#query] = query[#query] .. ' [[Has inventory icon::+]] [[Has infobox HTML::+]]'
           
            if tpl_args.link_type == 'skill' then
                query[#query] = query[#query] .. ' [[Concept:Skill gems]]'
            end
        end
       
        query[#query+1] = '?Has name'
        query[#query+1] = '?Has inventory icon'
        query[#query+1] = '?Has infobox HTML'
        query[#query+1] = '?Has alternate inventory icons'
        query[#query+1] = '?Has inventory width'
        query[#query+1] = '?Has inventory height'
       
        -- attributes
        result = util.smw.query(query, frame)
       
        local err
        if #result == 0 then
            err = util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
                'No results found for search parameter "%s".',
                tpl_args.page or tpl_args.item_name or tpl_args.item_name_exact
            )}
        elseif #result > 1 then
            err = util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
                'Too many results for search parameter "%s". Consider using page parameter instead.',
                tpl_args.page or tpl_args.item_name or tpl_args.item_name_exact
            )}
        end
       
        if err ~= nil then
            return err .. core.item_link_broken_cat
        end
       
        result = result[1]
    else
        result = {tpl_args.page or tpl_args.item_name_exact}
    end
   
    for _, k in ipairs(core.item_link_params) do
        local prop = core.map[k].property
        if tpl_args[k] ~= nil then
            result[prop] = tpl_args[k]
        end
    end
   
    if tpl_args.image ~= nil then
        if result['Has alternate inventory icons'] == '' then
            return util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
                'Image parameter was specified, but there is no alternate art defined on page "%s"',
                result[1]
            ) .. core.item_link_broken_cat}
        end
       
        result['Has alternate inventory icons'] = util.string.split(result['Has alternate inventory icons'], '<MANY>')
       
        local index = tonumber(tpl_args.image)
        if index ~= nil then
            img = result['Has alternate inventory icons'][index]
        else
            -- offset 1 is needed
            local suffix = string.len(' inventory icon.png') + 1
            -- add an extra offset by 1 to account for the space
            local prefix = string.len(string.sub(result['Has inventory icon'], 1, -suffix)) + 2
           
            for _, filename in ipairs(result['Has alternate inventory icons']) do
                if string.sub(filename, prefix, -suffix) == tpl_args.image then
                    img = filename
                    break
                end
            end
        end
       
        if img == nil then
            return util.misc.raise_error_or_return{raise_required=true, args=tpl_args, msg=string.format(
                'Alternate art with index/name "%s" not found on page "%s"',
                tpl_args.image, result[1]
            ) .. core.item_link_broken_cat}
        end
    elseif result['Has inventory icon'] ~= '' then
        img = result['Has inventory icon']
    end
   
    -- output
   
    local container = mw.html.create('span')
    container:attr('class', 'inline-infobox-container')
   
    if not tpl_args.large then
        container:wikitext(string.format('[[%s]]', img))
    end
     
    container:wikitext(string.format('[[%s|%s]]', result[1], result['Has name'] or result[1]))
       
    if result['Has infobox HTML'] ~= '' then
        container
            :tag('span')
                :attr('class', 'inline-infobox-hover')
                :wikitext(result['Has infobox HTML'])
                :wikitext(string.format('[[%s]]', img))
                :done()
    end
   
    if tpl_args.large then
        local width = tonumber(result['Has inventory width']) or tonumber(tpl_args.width)
        local height = tonumber(result['Has inventory height']) or tonumber(tpl_args.height)
       
        if width and height then
            img = string.format('[[%s|%sx%spx]]', img, width*c.image_size, height*c.image_size)
        elseif width then
            img = string.format('[[%s|%spx]]', img, width*c.image_size)
        elseif height then
            img = string.format('[[%s|x%spx]]', img, height*c.image_size)
        else
            img = string.format('[[%s]]', img)
        end
   
        container:wikitext(img)
    end
       
    return tostring(container)
end
 
--
-- Template:Il
--
 
function p.item_link_compability (frame)
    if util.misc.is_frame(frame) then
        frame.args.raise = true
    else
        frame.raise = true
    end
   
    local result
 
    local status, err = pcall(function ()
        result = p.item_link(frame)
    end)
    mw.logObject(err)
   
    if status then
        return result
    elseif string.match(err, ".*Too many results.*") then
        return err .. core.item_link_broken_cat
    else
        return require('Module:Item').itemLink(frame)
    end
end
 
 
-- ----------------------------------------------------------------------------
-- Result formatting templates for SMW queries
-- ----------------------------------------------------------------------------
 
--
-- Template:
--
 
function p.simple_item_list_row(frame)
    -- Args
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = util.misc.get_frame(frame)
   
    --
    local args = util.string.split_args(tpl_args.userparam, {sep=', '})
    tpl_args.userparam = args
   
    local link = p.item_link{page=tpl_args[1], name=tpl_args['?Has name'], inventory_icon=tpl_args['?Has inventory icon'] or '', html=tpl_args['?Has infobox HTML'] or ''}
    if args.format == nil then
        return '* ' .. link
    elseif args.format == 'none' then
        return link
    elseif args.format == 'li' then
        return string.format('<li>%s</li>', link)
    else
        error(string.format('Unrecognized format parameter "%s"', args.format))
    end
end
 
-- ----------------------------------------------------------------------------
-- Reponsibile for subtemplates of Template:SMW item table
--
 
function p.item_table(frame)
    -- args
    local tpl_args = getArgs(frame, {
            parentFirst = true
        })
    frame = util.misc.get_frame(frame)
   
    local row_infos = {}
    for _, row_info in ipairs(core.result.generic_item) do
        if row_info.arg == nil or tpl_args[row_info.arg] then
            row_infos[#row_infos+1] = row_info
        end
    end
   
    -- Parse stat arguments
    local stat_columns = {}
    local query_stats = {}
    local stat_results = {}
    local i = 0
    repeat
        i = i + 1
       
        local prefix = string.format('stat_column%s_', i)
        local col_info = {
            header = tpl_args[prefix .. 'header'] or tostring(i),
            format = tpl_args[prefix .. 'format'],
            order = tonumber(tpl_args[prefix .. 'order']) or (10000000 + i),
            stats = {},
        }
       
        local j = 0
        repeat
            j = j +1
       
            local stat_info = {
                id = tpl_args[string.format('%sstat%s_id', prefix, j)],
            }
           
            if stat_info.id then
                col_info.stats[#col_info.stats+1] = stat_info
                query_stats[stat_info.id] = {}
            else
                -- Stop iteration entirely if this was the first index but no stat was supplied. We assume that we stop in this case.
                if j == 1 then
                    i = nil
                end
                -- stop iteration
                j = nil
            end
        until j == nil
       
        -- Don't add this column if no stats were provided.
        if #col_info.stats > 0 then
            stat_columns[#stat_columns+1] = col_info
        end
    until i == nil
   
    for _, col_info in ipairs(stat_columns) do
        local row_info = {
            --arg
            header = col_info.header,
            properties = {},
            display = function(tr, data, properties)
                local stat_texts = {}
                local num_stats = 0
                local avg = 0
                for _, stat_info in ipairs(col_info.stats) do
                    num_stats = num_stats + 1
                    -- stat results from outside body
                    local stat = (stat_results[data[1]] or {})[stat_info.id]
                    if stat ~= nil then
                        stat_texts[#stat_texts+1] = h.format_value(tpl_args, frame, stat, {no_color=true})
                        avg = avg + stat.avg
                    end
                end
               
                if num_stats ~= #stat_texts then
                    tr:wikitext(util.html.td.na())
                else
                    local text
                    if col_info.format then
                        text = string.format(col_info.format, unpack(stat_texts))
                    else
                        text = table.concat(stat_texts, ', ')
                    end
               
                    tr:tag('td')
                        :attr('data-sort-value', avg)
                        :attr('class', 'tc -mod')
                        :wikitext(text)
                end
            end,
            order = col_info.order,
        }
        table.insert(row_infos, row_info)
    end
   
    -- sort the rows
    table.sort(row_infos, function (a, b)
        return (a.order or 0) < (b.order or 0)
    end)
   
    -- Parse query arguments
    local query = {tpl_args.conditions}
    for key, value in pairs(tpl_args) do
        if string.sub(key, 0, 2) == 'q_' then
            query[string.sub(key, 3)] = value
        end
    end
   
    --Override and set defaults
    query.limit = 1000
   
    -- Set required fields
    query[#query+1] = '?Has name#'
    query[#query+1] = '?Has iventory icon#'
    query[#query+1] = '?Has infobox HTML#'
    query[#query+1] = '?Has inventory width#'
    query[#query+1] = '?Has inventory height#'
    for _, rowinfo in ipairs(row_infos) do
        if type(rowinfo.properties) == 'function' then
            rowinfo.properties = rowinfo.properties()
        end
        for _, property in ipairs(rowinfo.properties) do
            query[#query+1] = '?' .. property .. '#'
        end
    end
    local results = util.smw.query(query, frame)
   
    if #results == 0 and tpl_args.default ~= nil then
        return tpl_args.default
    end
   
    if #stat_columns > 0 then
        local continue = true
        local offset = 0
        while continue do
            query = {string.format('[[-Has subobject::<q>%s</q>]] [[Has stat id::+]]', tpl_args.conditions)}
            query[#query+1] = '?Has average stat value#'
            query[#query+1] = '?Has maximum stat value#'
            query[#query+1] = '?Has minimum stat value#'
            query[#query+1] = '?Has stat id#'
            query.limit = 1000
            query.offset = 0
            local temp = util.smw.query(query, frame)
            for _, row in ipairs(temp) do
                if query_stats[row['Has stat id']] ~= nil then
                    local stat = {
                        min = tonumber(row['Has minimum stat value']),
                        max = tonumber(row['Has maximum stat value']),
                        avg = tonumber(row['Has average stat value']),
                    }
                   
                    local page = util.string.split(row[1], '#')[1]
                    if stat_results[page] == nil then
                        stat_results[page] = {[row['Has stat id']] = stat}
                    else
                        stat_results[page][row['Has stat id']] = stat
                    end
                end
            end
           
            -- stop iteration if we didn't hit the query limit
            if #temp == 1000 then
                offset = offset + 1000
            else
                continue = false
            end
        end
    end
   
    local tbl = mw.html.create('table')
    tbl:attr('class', 'wikitable sortable item-table')
   
    -- Header
   
    local tr = tbl:tag('tr')
    tr
        :tag('th')
            :wikitext(tpl_args.header or 'Item')
            :done()
           
    for _, row_info in ipairs(row_infos) do
        tr
            :tag('th')
                :wikitext(row_info.header)
                :done()
     end
     end
      
      
     for _, row in ipairs(results) do
     -- Show additional error messages in console to help fixing them
        tr = tbl:tag('tr')
     if #tpl_args._errors > 0 then
      
        mw.log(table.concat(tpl_args._errors, '\n'))
        local il_args = {
            page=row[1],
            name=row['Has name'],
            inventory_icon=row['Has inventory icon'],
            html=row['Has infobox HTML'],
            width=row['Has inventory width'],
            height=row['Has inventory height'],
        }
       
        if tpl_args.large then
            il_args.large = tpl_args.large
        end
       
        tr
            :tag('td')
                :wikitext(p.item_link(il_args))
                :done()
               
        for _, rowinfo in ipairs(row_infos) do
            -- this has been cast from a function in an earlier step
            local display = true
            for _, property in ipairs(rowinfo.properties) do
                -- this will bet set to an empty value not nil confusingly
                if row[property] == '' then
                    display = false
                    break
                end
            end
            if display then
                rowinfo.display(tr, row, rowinfo.properties)
            else
                tr:wikitext(util.html.td.na())
            end
        end
     end
     end
      
      
     return tostring(tbl)
     if tpl_args.debug then
end
         mw.log(os.clock() - t)
 
         mw.log('Start logging tpl_args.')
 
         mw.logObject(tpl_args)
item_table_factory = {}
         mw.log('Stop logging tpl_args.')
function item_table_factory.intro(args)
        mw.log('Start logging core.map.')
    -- args:
        mw.logObject(core.map)
    --  data_array
        mw.log('Stop logging core.map.')
    --  header
   
    return function (frame)
         -- Args
        local tpl_args = getArgs(frame, {
            parentFirst = true
        })
        frame = util.misc.get_frame(frame)
       
        --
         tpl_args.userparam = util.string.split_args(tpl_args.userparam, {sep=', '})
          
        local tr = mw.html.create('tr')
         tr
            :tag('th')
                :wikitext(args.header)
                :done()
               
        for _, rowinfo in ipairs(args.data_array) do
            if rowinfo.arg == nil or tpl_args.userparam[rowinfo.arg] then
                tr
                    :tag('th')
                        :wikitext(rowinfo.header)
                        :done()
            end
        end
       
        return '<table class="wikitable sortable item-table">' .. tostring(tr)
     end
     end
end
     if tpl_args.test then
 
         tpl_args.out = out
-- Base test: =p.item_list_row{userparam='weapon', 'Clarity', ['?Has name'] = 'Clarity', ['?Has inventory icon'] = 'Clarity inventory icon.png', ['?Has infobox HTML'] = 'x', ['?Has inventory width'] = '1', ['?Has inventory height'] = '1'}
         return tpl_args
-- =p.item_list_row{userparam='weapon=1', ['?Has base minimum physical damage'] = '5', ['?Has minimum physical damage range average'] = '5', ['?Has minimum physical damage range minimum'] = '5', ['?Has minimum physical damage range maximum'] = '5', ['?Has base maximum physical damage'] = '6', ['?Has maximum physical damage range average'] = '8', ['?Has maximum physical damage range minimum'] = '7', ['?Has maximum physical damage range maximum'] = '9', 'Clarity', ['?Has name'] = 'Clarity', ['?Has inventory icon'] = 'Clarity inventory icon.png', ['?Has infobox HTML'] = 'x', ['?Has inventory width'] = '1', ['?Has inventory height'] = '1'}
 
function item_table_factory.row(args)
    -- args:
     --  data_array
    return function (frame)
        -- Args
        local tpl_args = getArgs(frame, {
            parentFirst = true
        })
        frame = util.misc.get_frame(frame)
       
        --
        tpl_args.userparam = util.string.split_args(tpl_args.userparam, {sep=', '})
       
        local tr = mw.html.create('tr')
       
        local il_args = {
            page=tpl_args[1],
            name=tpl_args['?Has name'],
            inventory_icon=tpl_args['?Has inventory icon'],
            html=tpl_args['?Has infobox HTML'],
            width=tpl_args['?Has inventory width'],
            height=tpl_args['?Has inventory height'],
        }
        if tpl_args.userparam.large then
            il_args.large = tpl_args.userparam.large
        end
       
         tr
            :tag('td')
                :wikitext(p.item_link(il_args))
                :done()
               
        for _, rowinfo in ipairs(args.data_array) do
            if rowinfo.arg == nil or tpl_args.userparam[rowinfo.arg] then
                local value
                if rowinfo.property ~= nil then
                    value = tpl_args['?' .. rowinfo.property]
                    if rowinfo.cast then
                        value = rowinfo.cast(value)
                    end
                end
                rowinfo.display(tr, value, tpl_args)
            end
        end
       
         return tostring(tr)
     end
     end
    return out
end
end
-- Template:SMW item table/skill_gem/intro
p.skill_gem_list_intro = item_table_factory.intro{data_array=core.result.skill_gem, header='Skill gem'}
-- Template:SMW item table/skill gem
p.skill_gem_list_row = item_table_factory.row{data_array=core.result.skill_gem}


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Item lists
-- Exported functions
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


function p.skill_gem_list_by_gem_tag(frame)
local p = {}
    -- Args
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = util.misc.get_frame(frame)
   
    if tpl_args.class == 'Support Skill Gems' then
    elseif tpl_args.class == 'Active Skill Gems' then
    else
        error('invalid item class')
    end


    local query = {}
    query[#query+1] = string.format('[[Has item class::%s]]', tpl_args.class)
    query[#query+1] = '?Has gem tags'
    query[#query+1] = '?Has name'
    query[#query+1] = '?Has inventory icon'
    --query[#query+1] = '?Has infobox HTML'
    query.limit = 5000
    query.sort = 'Has name'
   
    local results = util.smw.query(query, frame)
   
    local tags = {}
   
    for _, row in ipairs(results) do
        row['Has gem tags'] = util.string.split(row['Has gem tags'], '<MANY>')
        for _, tag in ipairs(row['Has gem tags']) do
            if tags[tag] == nil then
                tags[tag] = {}
            end
            table.insert(tags[tag], row)
        end
    end
   
    local tags_sorted = {}
    for tag, _ in pairs(tags) do
        table.insert(tags_sorted, tag)
    end
    table.sort(tags_sorted)
   
    local tbl = mw.html.create('table')
    tbl
        :attr('class', 'wikitable sortable')
        :tag('tr')
            :tag('th')
                :wikitext('Tag')
                :done()
            :tag('th')
                :wikitext('Skills')
                :done()
            :done()
   
    for _, tag in ipairs(tags_sorted) do
        local rows = tags[tag]
        local tr = tbl:tag('tr')
        tr
            :tag('td')
                :wikitext(tag)
           
        local td = tr:tag('td')
        for i, row in ipairs(rows) do
            td:wikitext(p.item_link{page=row[1], name=row['Has Name'], inventory_icon=row['Has inventory icon'], html=row['Has infobox HTML'] or ''})
            if i < #rows then
                td:wikitext('<br>')
            end
        end
    end
 
    return tostring(tbl)
end
-- ----------------------------------------------------------------------------
-- Misc. Item templates
-- ----------------------------------------------------------------------------
--
-- Template:Item class
--
--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})


function p.item_class (frame)
p.item = p.main
    -- Get args
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = util.misc.get_frame(frame)
if not doInfoCard then
doInfoCard = require('Module:Infocard')._main
end
   
    core.factory.table_cast('name', {key='full', tbl=m_game.constants.item.class})(tpl_args, frame)
   
    if tpl_args.name_list ~= nil then
        tpl_args.name_list = util.string.split(tpl_args.name_list, ', ')
    else
        tpl_args.name_list = {}
    end
   
    --
   
    local ul = mw.html.create('ul')
    for _, item in ipairs(tpl_args.name_list) do
        ul
            :tag('li')
                :wikitext(item)
                :done()
    end
   
 
    -- Output Infocard
   
    local tplargs = {
        ['header'] = tpl_args.name,
        ['subheader'] = '[[Item class]] ' .. util.html.abbr('(?)', 'Item classes categorize items. Classes are often used to restrict items or skill gems to a specific class or by item filters'),
        [1] = 'Also referred to as:' .. tostring(ul),
    }
   
    -- cats
   
    local cats = {
        'Item classes',
        tpl_args.name,
    }
   
    -- Done
   
    return doInfoCard(tplargs) .. util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
end
 
-- ----------------------------------------------------------------------------
-- Debug stuff
-- ----------------------------------------------------------------------------
 
p.debug = {}
function p.debug.show_range_vars ()
    for _, prop in ipairs({'HTML', 'range text', 'range colour'}) do
        for var, data in pairs(core.stat_map) do
            mw.logObject(string.format('%s %s', data.property, prop))
        end
       
        for _, data in ipairs(core.dps_map) do
            mw.logObject(string.format('Has %s %s', data.property, prop))
        end
    end
end
 
function p.debug.generic_item_all()
    keys = {}
    for _, data in ipairs(core.result.generic_item) do
        keys[#keys+1] = string.format("['%s'] = '1'", data.arg)
    end
   
  return table.concat(keys, ', ')
end


return p
return p

Latest revision as of 23:36, 7 April 2024

Module documentation[view] [edit] [history] [purge]


This module is used on 13,000+ pages.

To avoid major disruption and server load, do not make unnecessary edits to this module. Test changes to this module first using its /sandbox and /testcases subpages . All of the changes can then be applied to this module in a single edit.

Consider discussing changes on the talk page or on Discord before implementing them.

Lua logo

This module depends on the following other modules:

The module implements {{item}}.

Overview

This module is responsible for creating item boxes, various item lists, item links and other item-related tasks. In the process a lot of the input data is verified and also added as semantic property to pages; as such, any templates deriving from this module should not be used on user pages other then for temporary testing purposes.

This template is also backed by an export script in PyPoE which can be used to export item data from the game files which then can be used on the wiki. Use the export when possible. de:Modul:Item2 ru:Модуль:Item2

The above documentation is transcluded from Module:Item2/doc. (edit | history)
Editors can experiment in this module's sandbox (edit | diff) and testcases (edit | run) pages.
Subpages of this module.

-------------------------------------------------------------------------------
-- 
--                                Module:Item2
-- 
-- This module implements Template:Item.
-------------------------------------------------------------------------------

require('Module:No globals')
local m_util = require('Module:Util')
local m_item_util -- Lazy load require('Module:Item util')
local m_cargo = require('Module:Cargo')

-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')

local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')

-- Lazy loading
local f_process_skill_data -- require('Module:Skill').process_skill_data
local f_item_link -- require('Module:Item link').item_link
local f_query_area_info -- require('Module:Area').query_area_info
local f_process_recipes -- require('Module:Item2/recipes').process_recipes
local f_append_schema -- require('Module:Item2/cargo').append_schema

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')

local i18n = cfg.i18n

local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')

-- Declare early to avoid errors
local c = {}

-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------

local h = {}

-- Lazy loading for Module:Skill
function h.process_skill_data(tpl_args)
    if not f_process_skill_data then
        f_process_skill_data = use_sandbox and require('Module:Skill/sandbox').process_skill_data or require('Module:Skill').process_skill_data
    end
    return f_process_skill_data(tpl_args)
end

-- Lazy loading for Module:Item link
function h.item_link(args)
    if not f_item_link then
        f_item_link = require('Module:Item link').item_link
    end
    return f_item_link(args)
end

-- Lazy loading for Module:Area
function h.query_area_info(args)
    if not f_query_area_info then
        f_query_area_info = require('Module:Area').query_area_info
    end
    return f_query_area_info(args)
end

-- Lazy loading for Module:Item2/cargo
function h.append_schema(tpl_args, tables)
    if not f_append_schema then
        f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
    end
    return f_append_schema(tpl_args, tables)
end

-- Lazy loading for Module:Item2/recipes
function h.process_recipes(tpl_args)
    if not f_process_recipes then
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
    end
    return f_process_recipes(tpl_args)
end

function h.handle_range_args(tpl_args, key, field, value, options)
    local opt = {}
    for k, v in pairs(options or {}) do
        opt[k] = v
    end
    local html, val2 = m_util.html.format_value(tpl_args, value, opt)
    tpl_args[key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = val2.color
    opt.color = false
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, value, opt)
end

h.stat = {}
function h.stat.add(value, magnitude)
    value.min = value.min + magnitude.min
    value.max = value.max + magnitude.max
end

function h.stat.add_distance(value, magnitude)
    -- Stats for distance are 10x the display value
    value.min = value.min + (magnitude.min / 10)
    value.max = value.max + (magnitude.max / 10)
end

function h.stat.increased(value, magnitude)
    value.min = value.min * (1 + magnitude.min / 100)
    value.max = value.max * (1 + magnitude.max / 100)
end

function h.stat.increased_inverse(value, magnitude)
    value.min = value.min / (1 + magnitude.min / 100)
    value.max = value.max / (1 + magnitude.max / 100)
end

--
-- Processing
--

function h.process_arguments(tpl_args, params)
    tpl_args._processed_args = tpl_args._processed_args or {}
    tpl_args._base_item_args = tpl_args._base_item_args or {}
    for _, k in ipairs(params) do
        local arg_def = core.map[k]
        if arg_def == nil then
            if tpl_args.debug then
                error(string.format(i18n.debug.invalid_argument_key, k))
            end
        else
            if arg_def.inherit ~= false then
                table.insert(tpl_args._base_item_args, k)
            end
            if tpl_args[k] ~= nil and arg_def.deprecated == true then
                tpl_args._flags.uses_deprecated_parameters = true
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                table.insert(tpl_args._deprecated_args, k)
            end
            if arg_def.func ~= nil then
                tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
            end
            if tpl_args[k] == nil then
                if tpl_args.class_id and tpl_args._item_config.defaults[k] ~= nil and (not tpl_args._flags.is_derived or arg_def.inherit == false) then
                    -- Defaults based on item class
                    -- Ignore inherited fields if this is a derived item; these are set by the base item instead
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                elseif arg_def.default ~= nil then
                    -- General defaults
                    if type(arg_def.default) == 'function' then
                        tpl_args[k] = arg_def.default(tpl_args)
                    else
                        tpl_args[k] = arg_def.default
                    end
                end
            end
            tpl_args._processed_args[k] = true
        end
    end
end

--
-- Display
--

function h.strip_random_stats(tpl_args, stat_text)
    if tpl_args._flags.random_mods then
        repeat
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
            if text ~= nil then
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
            end
        until text == nil
    end
    return stat_text
end

function h.add_to_infobox_from_map(tpl_args, infobox, mapping)
    local statcont = mw.html.create('span')
        :addClass('item-stats')
    local count = 0 -- Number of groups in infobox
    for _, group in ipairs(mapping) do
        local lines = {}
        for _, line in ipairs(group) do
            local show = true
            if line.show == false then
                show = false
            elseif type(line.show) == 'function' then
                show = line.show(tpl_args)
            end
            if show then
                lines[#lines+1] = line.func(tpl_args)
            end
        end
        if #lines > 0 then
            count = count + 1
            local heading = ''
            if group.heading == nil then
            elseif type(group.heading) == 'function' then
                heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
            end
            statcont
                :tag('span')
                    :addClass('group ' .. (group.class or ''))
                    :wikitext(heading .. table.concat(lines, '<br>'))
                    :done()
        end
    end

     -- Add groups to infobox
    if count > 0 then
        infobox:node(statcont)
    end
end

function h.make_main_infobox(tpl_args)
    local infobox = mw.html.create('span')
        :addClass('item-box -' .. tpl_args.frame_type)
    
    if tpl_args.class_id == 'DivinationCard' then
        local divcard = infobox
            :tag('span')
                :addClass('divicard-wrapper')
        local card_background = tpl_args.card_background or {}
        if #card_background > 0 then
            divcard
                :tag('span')
                    :addClass('divicard-background')
                    :wikitext(string.format(
                        '[[%s|390px|gif]]',
                        string.format(
                            i18n.files.divination_card_background,
                            table.concat(card_background, '-')
                        )
                    ))
        end
        divcard
            :tag('span')
                :addClass('divicard-art')
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-frame')
                :done()
            :tag('span')
                :addClass('divicard-header')
                :wikitext(tpl_args.name)
                :done()
            :tag('span')
                :addClass('divicard-artlink')
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
                :done()
            :tag('span')
                :addClass('divicard-stack')
                :wikitext(tpl_args.stack_size)
                :done()
            :tag('span')
                :addClass('divicard-face')
                :tag('span')
                    :addClass('divicard-reward')
                    :wikitext(tpl_args.description)
                    :done()
                :tag('span')
                    :addClass('divicard-flavour')
                    :wikitext(tpl_args.flavour_text)
                    :done()
    else
        local line_type
        local name_line
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
        else
            line_type = 'single'
            name_line = tpl_args.name
        end

        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        local symbols
        local influences = tpl_args.influences or {}
        if tpl_args.is_replica then
            symbols = {'replica', 'replica'}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
        elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
            symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_searing_exarch_item or tpl_args.is_eater_of_worlds_item then
            symbols = {
                tpl_args.is_searing_exarch_item and 'searingexarch' or 'eaterofworlds',
                tpl_args.is_eater_of_worlds_item and 'eaterofworlds' or 'searingexarch'
            }
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
        end
        
        infobox
            :tag('span')
                :addClass('header -' .. line_type)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[1] or nil)
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :addClass('symbol')
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    :done()
            :done()
            
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
    end
    
    if tpl_args.skill_icon ~= nil then
        infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
    end
    
    return infobox
end

-- 
-- Factory
-- 

h.factory = {}

function h.factory.maybe_show_infobox_line(args)
    -- Verifies that a list of keys are present in tpl_args and that the item 
    -- should use those keys. Returns true if all conditions are met, otherwise 
    -- returns false.
    return function (tpl_args)
        local keys = args.keys or {}
        local conditions = args.conditions or {}
        if #keys == 0 then
            return false
        end
        for _, k in ipairs(keys) do
            if tpl_args[k] == nil then
                return false
            end
            local t = type(tpl_args[k])
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
                return false
            end
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
                return false
            end
        end
        return true
    end
end

function h.factory.display_raw_value(key)
    return function(tpl_args)
        return tpl_args[key]
    end
end

function h.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, value)
        args.tbl = args.tbl or tpl_args
        if args.tbl[args.key] then
            value = m_util.html.abbr(value, args.tbl[args.key])
        end
        return value
    end
end

-- ----------------------------------------------------------------------------
-- Additional configuration
-- ----------------------------------------------------------------------------

-- helper to loop over the range variables easier
c.range_map = {
    min = '_range_minimum',
    max = '_range_maximum',
    avg = '_range_average',
}

--
-- Contents here are meant to resemble the ingame infobox of items
--
c.item_infobox_groups = {
    -- [n]: 
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines: 
    --   [n]: 
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
        -- Item type (weapons, hideout decorations, abyss jewels)
        {
            show = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id] ~= nil
            end,
            func = function (tpl_args)
                return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        -- Cosmetic item type
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cosmetic_type'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('cosmetic_type'),
        },
        -- Gems
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local out = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                end
                return table.concat(out, ', ')
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'support_gem_letter_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'support_gem_letter_html',
                        color = false,
                    },
                },
                fmt = i18n.tooltips.support_icon,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local value = {
                    base = 1,
                    min = 1,
                    max = tpl_args.max_level,
                }
                local options = {
                    fmt = '%i',
                    color = 'value',
                }
                return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, value, options)
                )
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args)
                local parts = {}
                for k, v in pairs(m_game.constants.skill.cost_types) do
                    parts[#parts+1] = {
                        key = 'cost_' .. k,
                        func = function (tpl_args, value)
                            if string.find(k, 'PerMinute', 1, true) then
                                value = value / 60 -- Cost per second
                            end
                            return value
                        end,
                        fmt = '%i',
                        inline = string.format(
                            '%%s%s %s',
                            string.find(k, 'Percent', 1, true) and '%%' or '',
                            v.long_upper
                        ),
                    }
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.cost,
                }(tpl_args)
            end,
        },
        {
            show = function (tpl_args)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'mana_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Mana'].long_upper,
                    },
                    {
                        key = 'life_reservation_flat',
                        fmt = '%i',
                        inline = '%s ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                    {
                        key = 'life_reservation_percent',
                        fmt = '%i',
                        inline = '%s%% ' .. m_game.constants.skill.cost_types['Life'].long_upper,
                    },
                },
                sep = ', ',
                fmt = i18n.tooltips.reservation,
            },
        },
        {
            show = true, -- TODO: Show only if has cost_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cost_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.cost_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has cooldown
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cooldown',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.cooldown_time,
            },
        },
        {
            -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_souls_requirement
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.vaal_souls_per_use,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_stored_uses
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_soul_gain_prevention_time',
                        hide_default = 0,
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data, 
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
            end,
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'cast_time',
                            fmt = function (tpl_args, value)
                                if value.min == 0 then
                                    return i18n.tooltips.instant_cast_time
                                end
                                return '%.2f ' .. m_game.units.seconds.short_lower
                            end,
                        },
                    },
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
                }(tpl_args)
            end,
        },
        {
            show = true, -- TODO: Show only if has attack_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_time',
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.attack_time,
            },
        },
        {
            show = true, -- TODO: Show only if has critical_strike_chance
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'critical_strike_chance',
                        hide_default = 0,
                        fmt = '%.2f%%',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = true, -- TODO: Show only if has attack_speed_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_speed_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.attack_speed_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                    },
                },
                fmt = i18n.tooltips.damage_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_effectiveness
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_effectiveness',
                        hide_default = 100,
                        fmt = '%i',
                        inline = '%s%%',
                    },
                },
                fmt = i18n.tooltips.damage_effectiveness,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'projectile_speed'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'projectile_speed',
                    },
                },
                fmt = i18n.tooltips.projectile_speed,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'radius'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'radius',
                        func = h.factory.descriptor_value{key='radius_description'},
                    },
                    {
                        key = 'radius_secondary',
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.aoe_radius,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'quality'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.quality,
            },
        },
        -- Weapons
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.physical_damage,
            },       
        },
        {
            show = true, -- Elemental Damage
            func = function (tpl_args)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                    if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,      
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_damage_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.chaos_damage,
            },       
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'critical_strike_chance_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'critical_strike_chance_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'attack_speed_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'attack_speed_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.attacks_per_second,
            },
        },
        {
            show = function (tpl_args)
                -- Do not show for ranged weapons
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                    return false
                end
                return h.factory.maybe_show_infobox_line{
                    keys = {'weapon_range_html'},
                }(tpl_args)
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'weapon_range_html',
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.units.metres.long_lower,
                    },
                },
                fmt = i18n.tooltips.weapon_range,
            },
        },
        -- Maps
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_area_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_area_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_tier,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'unique_map_guild_character',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_quantity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_quantity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_rarity_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_rarity,
            },
        },
        {
            show = function (tpl_args)
                return tpl_args.class_id == 'Map'
            end,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_pack_size_+%',
                        fmt = '%i',
                        color = 'mod',
                        inline = '+%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.monster_pack_size,
            },
        },
        -- Jewels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_limit',
                    },
                },
                fmt = i18n.tooltips.limited_to,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_radius_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_radius_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        -- Flasks
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
            --func = core.factory.display_flask('flask_mana'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_mana_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_mana_recovery,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_life_html', 'flask_duration_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_life_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_life_recovery,
            },
        },
        {
            -- don't display for mana/life flasks
            show = function (tpl_args)
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    if tpl_args[k] ~= nil then
                        return false
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_duration_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'charges_per_use_html', 'charges_max_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'charges_per_use_html',
                        color = false, -- html already has color
                    },
                    {
                        key = 'charges_max_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.flask_charges_per_use,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'buff_stat_text'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'buff_stat_text',
                        color = 'mod',
                    },
                },
            },
        },
        -- Armor
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'block_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'block_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'evasion_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'evasion',
                    },
                },
                fmt = i18n.tooltips.evasion,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'energy_shield_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'ward_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'ward_html',
                        color = false, -- html already has color
                        hide_default = 0,
                        hide_default_key = 'ward',
                    },
                },
                fmt = i18n.tooltips.ward,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'movement_speed'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%i%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
        },
        -- Stackables
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'stack_size'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essences
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'essence_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
        },
        -- Oils
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'blight_item_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Tattoos
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_target'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_target',
                    },
                },
                fmt = i18n.tooltips.tattoo_target,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_limit'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_limit',
                    },
                },
                fmt = i18n.tooltips.tattoo_limit,
            },
        },
        -- Harvest seeds (upper section)
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return i18n.tooltips.seed_monster
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_type_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_growth_cycles'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Heist
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_npcs'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
        -- Sentinels
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_duration'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_duration',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowers'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowers',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowers,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_empowerment'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_empowerment',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_empowerment,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_monster',
                    },
                    {
                        key = 'sentinel_monster_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_can_only_empower,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sentinel_charge'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'sentinel_charge',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.sentinel_charge,
            },
        },
        -- Corpse items
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_category_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'monster_category_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.monster_category,
            },
        },
        -- Embers of the Allflame
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_size_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'pack_size_html',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.pack_size,
            },
        },

        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'pack_leader_chance'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'pack_leader_chance',
                            hide_default = 0,
                            fmt = '%i%%',
                        },
                    },
                    fmt = tpl_args['pack_leader_chance'] < 100 and i18n.tooltips.pack_chance_to_contain_pack_leader or i18n.tooltips.pack_contains_pack_leader,
                }(tpl_args)
            end,
        },
    },
    -- Requirements
    {
        -- Talismans display their tier right above requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
        },
        -- Equipment requirements
        {
            show = true, -- Requires...
            func = function (tpl_args)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        color = false, -- html already has color
                        inline = i18n.tooltips.level_inline,
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        color = false, -- html already has color
                        inline = '%s ' .. m_game.constants.attributes[attr].short_upper,
                        hide = function (tpl_args, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].short_lower]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                    }
                end
                return core.factory.infobox_line{
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.requires,
                }(tpl_args)
            end,
        },
        -- Tattoo requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_min_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_min_adjacent',
                        fmt = '%i',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_min_adjacent,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'tattoo_max_adjacent'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'tattoo_max_adjacent',
                        fmt = '%i',
                        color = 'value',
                        inline = i18n.tooltips.tattoo_maximum .. ' %s',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.tattoo_max_adjacent,
            },
        },
        -- Heist gear requirements
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                    },
                    {
                        key = 'heist_required_job',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
        },
    },
    -- Gem description
    {
        class = 'tc -gemdesc',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_description'},
            },
            func = h.factory.display_raw_value('gem_description'),
        },
    },
    -- Gem stats
    {
        class = 'tc -mod',
        {
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
            func = h.factory.display_raw_value('stat_text'),
        },
        {
            -- Gem quality selector widget
            -- Show in full infobox if gem has alternate quality
            -- Never show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and tpl_args._flags.is_alt_quality_gem and tpl_args._infobox_container == 'infobox'
            end,
            func = function (tpl_args)
                local html = mw.html.create()
                    :tag('br'):done()
                local widget = html:tag('span')
                    :addClass('gemqual-widget')
                    :wikitext(m_util.html.poe_color('value', string.format(i18n.tooltips.gem_quality_effect_bonus, '')))
                local qtypes = {}
                for k, quality_data in ipairs(tpl_args.skill_quality) do
                    qtypes[#qtypes+1] = m_game.constants.item.gem_quality_types[k].long_upper
                    local stats = widget:tag('span')
                        :addClass('gemqual-widget__stats')
                        :attr('data-qid', k)
                        :wikitext(quality_data.stat_text)
                    if k == 1 then
                        stats:addClass('is-selected')
                    end
                end
                widget:attr('data-qtypes', table.concat(qtypes, ','))
                return tostring(html)
            end,
        },
        {
            -- Superior quality bonus
            -- Show in full infobox if gem does not have alternate quality
            -- Always show in hover infobox
            show = function (tpl_args)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.quality_type1_stat_text and (not tpl_args._flags.is_alt_quality_gem or tpl_args._infobox_container == 'inline')
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality_type1_stat_text',
                        color = 'mod',
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                        inline_color = 'value',
                    },
                },
                fmt = ' <br> %s',
            },
        },
    },
    -- Implicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'implicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.implicit_stat_text)
                end
                return tpl_args.implicit_stat_text
            end,
        },
    },
    -- Explicit stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'explicit_stat_text'},
            },
            func = function (tpl_args)
                if tpl_args._infobox_container == 'inline' then
                    return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                end
                return tpl_args.explicit_stat_text
            end,
        },
    },
    -- Experience
    --[[{
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'experience'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                    },
                    {
                        key = 'seed_type_html',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
        },
    },
    {
        class = 'tc -crafted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('seed_effect'),
        },
    },
    -- Description
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'description'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('description'),
        },
        --[[{
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_lifeforce'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('monster_abilities'),
        },
    },
    -- Variations (for hideout decorations)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'variation_count'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.variation_count > 1 then
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                end
                return nil
            end,
        },
    },
    -- Corrupted
    {
        class = 'tc -corrupted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_corrupted'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_corrupted then
                    return i18n.tooltips.corrupted
                end
                return nil
            end,
        },
    },
    -- Mirrored
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_mirrored'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_mirrored then
                    return i18n.tooltips.mirrored
                end
                return nil
            end,
        },
    },
    -- Unmodifiable
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_unmodifiable'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_unmodifiable then
                    return i18n.tooltips.unmodifiable
                end
                return nil
            end,
        },
    },
    -- Flavour text
    {
        class = 'tc -flavour',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
    },
    -- Prophecy text
    {
        class = 'tc -value',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'prediction_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('prediction_text'),
        },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cannot_be_traded_or_modified'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.cannot_be_traded_or_modified then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
                return nil
            end,
        },
    },
    -- Help text
    {
        class = 'tc -help',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'help_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
    },
    -- Account-bound
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'is_account_bound'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                if tpl_args.is_account_bound then
                    return i18n.tooltips.account_bound
                end
                return nil
            end,
        },
    },
}

--
-- This is meant to show additional information about the item in a separate infobox
--
c.extra_display_groups = {
    {
        heading = i18n.tooltips.extra_info,
        class = '',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local fields = {
                    [false] = {
                        value = '✗',
                        sort = 0,
                        class = 'table-cell-xmark',
                    },
                    [true] = {
                        value = '✓',
                        sort = 1,
                        class = 'table-cell-checkmark',
                    },
                }
                
                local tbl = mw.html.create('table')
                tbl
                    :addClass('wikitable')
                    :attr('style', 'width:100%;')
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                    
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                    
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
                
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
                
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
                
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                    
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :addClass(field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
                
                return tostring(tbl)
            end
        },
    },
    -- Acquisition
    {
        heading = i18n.tooltips.acquisition,
        {
            show = function (tpl_args)
                if tpl_args.is_in_game == false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.not_in_game)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.drop_enabled == false and tpl_args.is_in_game ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args)
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args)
                local span = mw.html.create('span')
                span
                    :addClass('infobox-restricted-drop')
                    :wikitext(i18n.tooltips.drop_restricted)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.drop_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'acquisition_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                local tags = {}
                for _, v in pairs(tpl_args.acquisition_tags) do
                    if v then
                        tags[#tags+1] = string.format('[[%s|%s]]', cfg.acquisition_tags[v].page, cfg.acquisition_tags[v].name)
                    end
                end
                return table.concat(tags, ' • ')
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_areas_html'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_text'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
            },
        },
    },
    {
        -- Vendor prices
        heading = i18n.tooltips.purchase_costs,
        {
            show = function (tpl_args)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                    if #data > 0 then
                        return true
                    end
                end
                return false
            end,
            func = function (tpl_args)
                local tbl = mw.html.create('table')
                tbl
                    --:addClass('wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                    
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
                
                return tostring(tbl)
            end,
        },
    },
    {
        -- Vendor offer
        heading = i18n.tooltips.sell_price,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sell_price_order'},
            },
            func = function (tpl_args)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
        },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.physical_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'fire_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'fire_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.fire_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cold_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cold_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.cold_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'lightning_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'lightning_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.lightning_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.chaos_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'elemental_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'elemental_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.elemental_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'poison_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'poison_dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.poison_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'dps_html',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.dps,
            },
        },
    },
    -- Metadata
    {
        heading = i18n.tooltips.metadata,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'class'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'class',
                    },
                },
                fmt = i18n.tooltips.item_class,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'metadata_id'},
                conditions = {processed = true},
            },
            func = function (tpl_args)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'metadata_id',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        },
                    },
                    fmt = tostring(
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                }(tpl_args)
            end,
        },
    },
}

-- ----------------------------------------------------------------------------
-- Subroutines
-- ----------------------------------------------------------------------------

local s = {}

-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.

function s.get_item_config(tpl_args)
    -- Returns primary item configuration, based on item class

    local config = {
        tables = {}, -- Table names that data may be stored to
        args = {}, -- Args to process early
        late_args = {}, -- Args to process late
        defaults = {}, -- Defaults based on item class
    }
    for _, v in ipairs(cfg.tables) do
        table.insert(config.tables, v)
    end
    for _, v in ipairs(cfg.default_args) do
        table.insert(config.args, v)
    end
    for _, v in ipairs(cfg.late_args) do
        table.insert(config.late_args, v)
    end

    -- Process class_id
    h.process_arguments(tpl_args, {'class_id'})

    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
            end
            if row['defaults'] then
                for k, v in pairs(row['defaults']) do
                    config['defaults'][k] = v
                end
            end
            break
        end
    end
    local class_specifics = cfg.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(extend_keys) do
            if class_specifics[k] then
                for _, v in ipairs(class_specifics[k]) do
                    table.insert(config[k], v)
                end
            end
        end
        if class_specifics['defaults'] then
            for k, v in pairs(class_specifics['defaults']) do
                config['defaults'][k] = v
            end
        end
    end
    return config
end

function s.process_quest_rewards(tpl_args)
    local rid = 1
    local continue
    tpl_args.quest_rewards = {}
    tpl_args.vendor_rewards = {}
    repeat 
        continue = true
        local prefix = string.format('quest_reward%s_', rid)
        
        local input_args = {
            shared = {
                ['type'] = true, 
                ['quest'] = false, 
                ['quest_id'] = false, 
                ['act'] = true, 
                ['class_ids'] = false,
                },
            vendor = {
                ['npc'] = true,
            },
            quest = {
                ['sockets'] = false, 
                ['item_level'] = false, 
                ['rarity_id'] = false, 
                ['notes'] = false,
            },
        }
        
        local rdata = {}
        
        for key, is_required in pairs(input_args.shared) do
            rdata[key] = tpl_args[prefix .. key]
            if is_required then
                if rdata[key] == nil then
                    continue = false
                    break
                end
            end
        end
        
        if rdata.quest == nil or rdata.quest_id == nil then
            continue = false
        end
        
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            for key, is_required in pairs(input_args[rdata.type]) do
                rdata[key] = tpl_args[prefix .. key]
                if is_required then
                    if rdata[key] == nil then
                        continue = false
                        break
                    end
                end
            end
        else
            continue = false
        end
        
        if continue then
            rdata.classes = {}
            if rdata.class_ids ~= nil then
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                for index, class_id in ipairs(rdata.class_ids) do
                    local class = m_game.constants.characters[class_id] 
                    if class == nil then
                        error(string.format('Class id %s is invalid', class_id))
                    else
                        rdata.class_ids[index] = class.str_id
                        rdata.classes[index] = class.name
                    end
                end
            end
            
            
            if rdata.item_level then
                rdata.item_level = m_util.cast.number(rdata.item_level)
            end
            
            if rdata.rarity_id then
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                end
            end
            
            rdata._table = rdata.type .. '_rewards'
            rdata.type = nil
            
            tpl_args[rdata._table] = rdata
            
            m_cargo.store(rdata)
            
            -- TODO: Verify quests and quest ids?
        end
        
        rid = rid + 1
    until continue == false
end

function s.process_base_item(tpl_args)
    if not tpl_args._flags.is_derived then
        if tpl_args.rarity_id ~= 'normal' then
            error(i18n.errors.missing_base_item)
        end
        return
    end
    m_item_util = m_item_util or require('Module:Item util')
    local qargs = {}
    qargs.tables = tpl_args._item_config.tables
    qargs.join = {}
    for _, tbl in ipairs(tpl_args._item_config.tables) do
        if tbl ~= 'items' then
            qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
        end
    end
    qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
    qargs.fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
        'items.class_id',
        'items.rarity_id',
        'items.inventory_icon',
    }
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.field ~= nil then
            qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
        end
    end
    qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
    local result = m_item_util.query_item({
        metadata_id = tpl_args.base_item_id,
        page = tpl_args.base_item_page,
        item_name_exact = tpl_args.base_item,
        debug = tpl_args.debug,
    }, qargs)
    if result.error then
        result.error:throw(true)
    end
    if result['items.rarity_id'] ~= 'normal' then
        error(i18n.errors.base_item_wrong_rarity)
    end

    tpl_args.base_item = result['items.name']
    tpl_args.base_item_page = result['items._pageName']
    tpl_args.base_item_id = result['items.metadata_id']
    h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})

    tpl_args.base_item_icon = result['items.inventory_icon']

    -- Copy values
    for _, k in ipairs(tpl_args._base_item_args) do
        local arg_def = core.map[k]
        if arg_def.func_fetch ~= nil then
            arg_def.func_fetch(tpl_args)
        elseif arg_def.field ~= nil then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
            if value == nil then
                if tpl_args.debug then
                    mw.log(string.format(i18n.debug.base_item_field_not_found, arg_def.table, arg_def.field))
                end
            else
                local default = type(arg_def.default) == 'function' and arg_def.default(tpl_args) or arg_def.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == arg_def.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(arg_def.default) == 'table' and #arg_def.default == 0) then
                    tpl_args[k] = value
                    if arg_def.func ~= nil then
                        tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                    end
                    if arg_def.func_copy ~= nil then
                        arg_def.func_copy(tpl_args, tpl_args[k])
                    end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end
            end
        end
    end

    -- Fetch implicit mods from base item
    local mods = m_cargo.query(
        {'items' ,'item_mods'},
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
        {
            join = 'items._pageID=item_mods._pageID',
            where = string.format(
                'items._pageName="%s" AND item_mods.is_implicit=true',
                tpl_args.base_item_page
            ),
        }
    )
    tpl_args._base_implicit_mods = {}
    for _, row in ipairs(mods) do
        table.insert(tpl_args._base_implicit_mods, {
            id = row['item_mods.id'],
            stat_text = row['item_mods.text'],
            is_implicit = true,
            is_random = m_util.cast.boolean(row['item_mods.is_random']),
        })
    end
end

function s.process_mods(tpl_args)
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}

    local function parse_mod_arg(tpl_args, type, index)
        local prefix = type .. index
        local mod_data = {
            is_implicit = type == 'implicit',
            is_explicit = type == 'explicit',
            is_map_fragment_bonus = type == 'map_fragment_bonus',
            is_random = false,
        }
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods

        -- By mod id
        local value = tpl_args[prefix]
        if value ~= nil then
            mod_data.id = value
            mod_data.stat_text = tpl_args[prefix .. '_text']
            table.insert(mods_table, mod_data)
            return true
        end

        -- By list of possible mod ids
        value = tpl_args[prefix .. '_random_list']
        if value ~= nil then
            value = m_util.cast.table(value)
            for _, id in ipairs(value) do
                local mod_data_copy = {}
                for k, v in pairs(mod_data) do
                    mod_data_copy[k] = v
                end
                mod_data_copy.id = id
                mod_data_copy.is_random = true
                mod_data_copy.stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, index)
                table.insert(mods_table, mod_data_copy)
            end
            tpl_args._flags.random_mods = true
            return true
        end

        -- By stat text
        value = tpl_args[prefix .. '_text']
        if value ~= nil then
            mod_data.result = false -- Not stored in Cargo table
            mod_data.stat_text = value
            table.insert(mods_table, mod_data)
            tpl_args._flags.text_modifier = true
            return true
        end

        return false
    end -- parse_mod_arg

    local types = {
        'implicit',
        'explicit',
        'map_fragment_bonus',
    }
    for _, t in ipairs(types) do
        local i = 1
        while parse_mod_arg(tpl_args, t, i) do
            i = i + 1
        end
    end

    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
    local implicit_mods = tpl_args._defined_implicit_mods or {}
    if #implicit_mods == 0 then
        implicit_mods = tpl_args._base_implicit_mods or {}
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                table.insert(mod_ids, mod_data.id)
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            table.insert(tpl_args._store_data, {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_explicit = mod_data.is_explicit,
                is_map_fragment_bonus = mod_data.is_map_fragment_bonus,
                is_random = mod_data.is_random,
            })
        end
        local results = m_cargo.query(
            {'mods'},
            {'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            {
                where = string.format(
                    'mods.id IN ("%s")',
                    table.concat(mod_ids, '","')
                )
            }
        )
        for _, row in ipairs(results) do
            local mod_data = mods[row['mods.id']]
            mod_data.result = row
            if mod_data.is_random == false then
                -- Modifiers contribute to level requirement
                -- Update base level requirement only if this is an implicit
                local args = {
                    'required_level_final',
                    mod_data.is_implicit and 'required_level' or nil,
                }
                for _, v in ipairs(args) do
                    local req = math.floor(tonumber(row['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[v] then
                        tpl_args[v] = req
                    end
                end
            end
        end
        
        -- fetch stats
        results = m_cargo.query(
            {'mods', 'mod_stats'},
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
            {
                join = 'mods._pageID=mod_stats._pageID',
                where = string.format(
                    'mods.id IN ("%s") AND mod_stats.id IS NOT NULL',
                    table.concat(mod_ids, '","')
                ),
            }
        )
        for _, row in ipairs(results) do
            -- Stat data
            local mod_data = mods[row['mods.id']]
            mod_data.result.stats = mod_data.result.stats or {}
            table.insert(mod_data.result.stats, row)
            local stat_id = row['mod_stats.id']
            local value = {
                min = tonumber(row['mod_stats.min']),
                max = tonumber(row['mod_stats.max']),
            }
            local tbl = mod_data.is_random and '_random_stats' or '_stats'
            core.add_stat(tpl_args, stat_id, value, {tbl=tbl, mod=mod_data})
        end
        
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                }
            )
            
            for _, data in ipairs(results) do
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']), 
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
         end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
        end
        
        if missing_sell_price then
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
        
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in core.map.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._store_data[#tpl_args._store_data+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end

function s.process_stats(tpl_args)
    tpl_args._stats = tpl_args._stats or {}

    -- Extra stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'}) -- Populates tpl_args.extra_stats
    for _, stat in ipairs(tpl_args.extra_stats) do
        core.add_stat(tpl_args, stat.id, stat.value or stat)
    end
    
    -- Handle local item stat math - additions, increases, etc.
    for key, stat_def in pairs(core.stat_map) do
        local arg = stat_def.arg or key
        local value = {}
        if type(arg) == 'table' then
            value.min = tpl_args[arg.min]
            value.max = tpl_args[arg.max]
            value.base_min = tpl_args[arg.min]
            value.base_max = tpl_args[arg.max]
        else
            value.min = tpl_args[arg]
            value.max = tpl_args[arg]
            value.base = tpl_args[arg]
        end
        if value.min ~= nil and value.max ~= nil then
            -- Determine whether stat is overridden; if so, other calculations can be ignored
            local overridden = false
            if stat_def.stats_override then
                for id, v in pairs(stat_def.stats_override) do
                    if tpl_args._stats[id] then
                        -- If for some reason there is more than one of the same override stat, apply the final one.
                        local stat_value = tpl_args._stats[id][#tpl_args._stats[id]]
                        if stat_value then
                            if type(v) == 'table' then
                                value.min = v.min
                                value.max = v.max
                                overridden = true
                            elseif v then -- Use the stat value
                                value.min = stat_value.min
                                value.max = stat_value.max
                                overridden = true
                            end
                        end
                    end
                end
            end
            if not overridden then
                local operations = {'add', 'add_distance', 'increased', 'increased_inverse'}
                for _, o in ipairs(operations) do
                    local stat_ids = stat_def['stats_' .. o]
                    if stat_ids then
                        local total = {min=0, max=0}
                        for _, id in ipairs(stat_ids) do
                            if tpl_args._stats[id] then
                                for _, s in ipairs(tpl_args._stats[id]) do
                                    total.min = total.min + s.min
                                    total.max = total.max + s.max
                                end
                            end
                        end
                        h.stat[o](value, total)
                    end
                end
                if stat_def.minimum ~= nil then
                    for _, k in ipairs({'min', 'max'}) do
                        if value[k] < stat_def.minimum then
                            value[k] = stat_def.minimum 
                        end
                    end
                end
            end
            value.avg = (value.min + value.max) / 2

            for short_key, range_def in pairs(c.range_map) do
                tpl_args[stat_def.field .. range_def] = value[short_key]
            end
            
            -- process to HTML to use on list pages or other purposes
            h.handle_range_args(tpl_args, key, stat_def.field, value, stat_def.html_fmt_options)
        end
    end

    -- Transpose stats into cargo data
    for _, tbl in ipairs({'_stats', '_random_stats'}) do
        if tpl_args[tbl] then
            for stat_id, stats in pairs(tpl_args[tbl]) do
                for _, stat_data in ipairs(stats) do
                    table.insert(tpl_args._store_data, {
                        _table = 'item_stats',
                        id = stat_id,
                        min = stat_data.min,
                        max = stat_data.max,
                        avg = stat_data.avg,
                        mod_id = stat_data.mod and stat_data.mod.id or nil
                    })
                end
            end
        end
    end
end

function s.process_weapon_dps(tpl_args)
    for key, dps_def in pairs(core.dps_map) do
        local damage = {
            min = {},
            max = {},
        }
        for var_type, value in pairs(damage) do
            -- covers the min/max/avg range
            for short_key, range_def in pairs(c.range_map) do
                value[short_key] = 0
                for _, damage_key in ipairs(dps_def.damage_args) do
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_def)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_def in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_def)]
            value[short_key] = result
            tpl_args[string.format('%s%s', dps_def.field, range_def)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, key, dps_def.field, value, dps_def.html_fmt_options)
        end
    end
end

function s.process_gem_variants(tpl_args)
    if not tpl_args._flags.is_derived and tpl_args.metadata_id == nil then
        -- If this is a base item, then it needs a metadata ID in order to find its variants.
        return
    end
    local variants = {}
    local title = mw.title.getCurrentTitle()
    local current = {
        page = title.prefixedText,
        name = tpl_args.name,
        id = tpl_args.metadata_id,
        icon = tpl_args.inventory_icon,
        current = true,
    }
    local results
    local tables = {'items', 'skill_gems', 'skill'}
    local fields = {
        'items._pageName=page',
        'items.name=name',
        'items.metadata_id=id',
        'items.inventory_icon=icon'
    }
    local qargs = {
        join = 'items._pageID=skill_gems._pageID, items._pageID=skill._pageID',
        orderBy = 'skill.skill_id ASC',
    }

    if tpl_args.class_id == 'Active Skill Gem' then
        if tpl_args.is_vaal_skill_gem then
            variants.vaal = current
            
            -- Query base skill gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Active Skill Gem"
                  AND skill_gems.vaal_variant_id = "%s"
                  AND skill_gems.is_vaal_skill_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            -- Determine base skill gem
            if tpl_args._flags.is_derived then
                variants.base = {
                    page = tpl_args.base_item_page,
                    name = tpl_args.base_item,
                    id = tpl_args.base_item_id,
                    icon = tpl_args.base_item_icon,
                }
            else
                variants.base = current
            end

            if tpl_args.vaal_variant_id ~= nil then
                -- Query Vaal skill gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Active Skill Gem"
                      AND skill_gems.is_vaal_skill_gem = true]],
                    tpl_args.vaal_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.vaal = results[1]
                end
            end
        end
        if variants.base then
            -- Query transfigured skill gem variants
            qargs.where = string.format(
                [[items.metadata_id IS NULL
                  AND items.base_item_id = "%s"
                  AND items.class_id = "Active Skill Gem"]],
                variants.base.id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.transfigured = {}
                for _, row in ipairs(results) do
                    row.current = row.page == title.prefixedText
                    table.insert(variants.transfigured, row)
                end
            end
        end
    elseif tpl_args.class_id == 'Support Skill Gem' then
        if tpl_args.is_awakened_support_gem then
            variants.awakened = current
            
            -- Query base support gem
            qargs.where = string.format(
                [[items.metadata_id IS NOT NULL
                  AND items.class_id = "Support Skill Gem"
                  AND skill_gems.awakened_variant_id = "%s"
                  AND skill_gems.is_awakened_support_gem = false]],
                tpl_args.metadata_id
            )
            if title.namespace == 0 then
                qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
            end
            results = m_cargo.query(tables, fields, qargs)
            if #results > 0 then
                variants.base = results[1]
            end
        else
            variants.base = current

            if tpl_args.awakened_variant_id ~= nil then
                -- Query awakened support gem variant
                qargs.where = string.format(
                    [[items.metadata_id = "%s"
                      AND items.class_id = "Support Skill Gem"
                      AND skill_gems.is_awakened_support_gem = true]],
                    tpl_args.awakened_variant_id
                )
                if title.namespace == 0 then
                    qargs.where = qargs.where .. ' AND items._pageNamespace = 0'
                end
                results = m_cargo.query(tables, fields, qargs)
                if #results > 0 then
                    variants.awakened = results[1]
                end
            end
        end
    end
    tpl_args._variants = {}
    table.insert(tpl_args._variants, variants.base)
    if variants.transfigured then
        for _, v in ipairs(variants.transfigured) do
            table.insert(tpl_args._variants, v)
        end
    end
    table.insert(tpl_args._variants, variants.vaal)
    table.insert(tpl_args._variants, variants.awakened)
end

function s.get_categories(tpl_args)
    local cats = {}
    if tpl_args._flags.is_prophecy then
        table.insert(cats, i18n.categories.prophecies)
    elseif tpl_args._flags.is_blight_item then
        table.insert(cats, i18n.categories.oils)
    elseif tpl_args._flags.is_talisman then
        table.insert(cats, i18n.categories.talismans)
    elseif tpl_args._flags.is_essence then
        table.insert(cats, i18n.categories.essences)
    elseif tpl_args._flags.is_fossil then
        table.insert(cats, i18n.categories.fossils)
    elseif tpl_args._flags.is_scarab then
        table.insert(cats, i18n.categories.scarabs)
    elseif tpl_args._flags.is_tattoo then
        table.insert(cats, i18n.categories.tattoos)
    elseif tpl_args._flags.is_delirium_orb then
        table.insert(cats, i18n.categories.delirium_orbs)
    elseif tpl_args._flags.is_catalyst then
        table.insert(cats, i18n.categories.catalysts)
    elseif tpl_args.class_id == 'Map' and tpl_args.rarity_id == 'normal' then
        table.insert(cats, string.format(i18n.categories.maps_by_series, tpl_args.map_series))
    elseif tpl_args.class_id == 'Microtransaction' and tpl_args.cosmetic_type and m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats then
        for _, v in ipairs(m_game.constants.item.cosmetic_item_types[tpl_args.cosmetic_type].cats) do
            table.insert(cats, v)
        end
    elseif m_game.constants.item.classes[tpl_args.class_id].cats then
        for _, v in ipairs(m_game.constants.item.classes[tpl_args.class_id].cats) do
            if tpl_args.rarity_id == 'unique' then
                table.insert(cats, string.format(i18n.categories.unique_affix, v))
            else
                table.insert(cats, v)
            end
        end
    else
        table.insert(cats, tpl_args.class)
    end
    
    if tpl_args._flags.is_derived then
        table.insert(cats, i18n.categories.derived_items)
    else
        table.insert(cats, i18n.categories.base_items)
    end

    for _, tag in ipairs(tpl_args.acquisition_tags) do
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
            table.insert(cats, cfg.acquisition_tags[tag].cat)
        end
    end
    
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
    end
    
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        for _, tag in ipairs(tpl_args.gem_tags) do
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
        end
    end

    if tpl_args._flags.is_derived and #tpl_args._defined_implicit_mods > 0 then
        table.insert(cats, i18n.categories.implicit_modifier_override)
    end
    
    if #tpl_args.alternate_art_inventory_icons > 0 then
        table.insert(cats, i18n.categories.alternate_artwork)
    end

    if tpl_args._flags.has_legacy_drop_areas == true then
        mw.log('IDs of legacy map areas used in drop_areas:')
        mw.logObject(tpl_args._legacy_drop_areas)
        table.insert(cats, i18n.categories.legacy_drop_areas)
    end
    
    if tpl_args.release_version == nil then
        table.insert(cats, i18n.categories.missing_release_version)
    end
    
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        table.insert(cats, i18n.categories.improper_modifiers)
    end
    
    for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            table.insert(cats, i18n.categories[k])
        end
    end

    if tpl_args.disable_automatic_recipes == true then
        table.insert(cats, i18n.categories.automatic_recipes_disabled)
    end

    if tpl_args._flags.uses_deprecated_parameters == true then
        mw.log('Deprecated parameters used:')
        mw.logObject(tpl_args._deprecated_args)
        table.insert(cats, i18n.categories.deprecated_parameters)
    end

    if tpl_args._flags.has_deprecated_skill_parameters then
        table.insert(cats, i18n.categories.deprecated_skill_parameters)
    end
    return cats
end

-- ----------------------------------------------------------------------------
-- Main functions
-- ----------------------------------------------------------------------------

local function _main(tpl_args)
    local t = os.clock() -- Start time (for logging)
    tpl_args._flags = {}
    tpl_args._store_data = {}
    tpl_args._errors = {}
    
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args)

    -- Add table names to core.map and append range fields.
    h.append_schema(tpl_args, tpl_args._item_config.tables)
    
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args)

    -- Assume this is meant to be a derived item if any base item parameters are set
    tpl_args._flags.is_derived = m_util.table.has_any_key(tpl_args, {'base_item_id', 'base_item_page', 'base_item'})
    
    -- Must validate some argument early. It is required for future things
    h.process_arguments(tpl_args, tpl_args._item_config.args)

    -- Base item
    s.process_base_item(tpl_args)

    -- Process arguments that require a particular flag to be set
    -- Used for subsets of item classes that have additional fields
    for k, v in pairs(cfg.flagged_args) do
        if tpl_args._flags[k] then
            h.process_arguments(tpl_args, v.args)
        end
    end
    
    -- Mods
    s.process_mods(tpl_args)

    -- Stats
    s.process_stats(tpl_args)

    -- Calculate and handle weapon dps
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args)
    end

    -- Skill gems
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.process_skill_data(tpl_args)
    end
    
    -- Late argument processing
    h.process_arguments(tpl_args, tpl_args._item_config.late_args)
    
    -- Recipes
    h.process_recipes(tpl_args)
    
    -- Quest reward info
    s.process_quest_rewards(tpl_args)

    -- Gem variants
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        s.process_gem_variants(tpl_args)
    end
    
    -- ------------------------------------------------------------------------
    -- Infobox handling 
    -- ------------------------------------------------------------------------

    --
    -- Tabs
    --

    local tabs
    if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then    
        tabs = mw.html.create('div')
            :addClass('itembox-tabs')
        for _, v in ipairs(tpl_args._variants) do
            local tab = tabs:tag('span')
            tab:addClass('itembox-tab')
            if v.current then
                tab:addClass('-selected')
            end
            if v.icon then
                tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
            else
                tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
        end
    end

    --
    -- Primary infobox
    --

    tpl_args._infobox_container = 'infobox'
    local infobox = h.make_main_infobox(tpl_args)
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        infobox:tag('span')
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
    end
    tpl_args.infobox_html = tostring(infobox)
    
    --
    -- Secondary infobox
    --
    
    local extra_infobox = mw.html.create('div')
        :addClass('item-box -' .. tpl_args.frame_type)
    h.add_to_infobox_from_map(tpl_args, extra_infobox, c.extra_display_groups)
    tpl_args.metabox_html = tostring(extra_infobox)
    
    -- 
    -- Output
    --
    
    local container = mw.html.create('div')
        :addClass('infobox-page-container')
    if tabs then
        container:node(tabs)
    end
    container
        :node(infobox)
        :node(extra_infobox)
        
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        container:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
    
    local out = tostring(container)
    
    local cats = s.get_categories(tpl_args)
    
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
    
    --
    --  Misc
    --
     
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end

    if query_id then
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    end
    
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------

    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args._infobox_container = 'inline'
    tpl_args.html = tostring(h.make_main_infobox(tpl_args))

    -- Map argument values for cargo storage
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        tpl_args._store_data[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local arg_def = core.map[k]
        if arg_def ~= nil then
            if arg_def.table ~= nil and arg_def.field ~= nil then
                if arg_def.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], arg_def.table, arg_def.field))
                    end
                end
                if tpl_args._store_data[arg_def.table] == nil then
                    error(string.format('Missing data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                if type(tpl_args._store_data[arg_def.table]) ~= 'table' then
                    error(string.format('Unexpected format of data for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
                end
                tpl_args._store_data[arg_def.table][arg_def.field] = v
            elseif arg_def.table ~= nil and arg_def.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \narg_def:\n%s', arg_def.table, k, mw.dumpObject(v), mw.dumpObject(arg_def)))
            elseif arg_def.table == nil and arg_def.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
            end
        end
    end
    
    -- Don't store cargo data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._store_data) do
            if attach[data._table] == nil then
                local i = 0 
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- One of the purposes of attaching is to facilitate table recreation.
                        -- Unfortunately, the Cargo extension's table recreation tool is 
                        -- very slow and often fails to rebuild the entire table.
                        mw.getCurrentFrame():expandTemplate{
                            title = string.format(i18n.templates.cargo_attach, data._table),
                            args = {}
                        }
                        break
                    end
                end
            end
            m_cargo.store(data, {
                debug = tpl_args.debug,
                sep = {
                    name_list = '�',
                },
            })
        end
    end
    
    -- Show additional error messages in console to help fixing them
    if #tpl_args._errors > 0 then
        mw.log(table.concat(tpl_args._errors, '\n'))
    end
    
    if tpl_args.debug then
        mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
        mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
        mw.logObject(core.map)
        mw.log('Stop logging core.map.')
    end
    if tpl_args.test then
        tpl_args.out = out
        return tpl_args
    end
    return out
end

-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------

local p = {}

--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})

p.item = p.main

return p
Retrieved from "https://www.poewiki.net/index.php?title=Module:Item2&oldid=1435558"