Module:Item2: Difference between revisions

From Path of Exile Wiki
Jump to navigation Jump to search
>OmegaK2
(crit column)
No edit summary
 
(587 intermediate revisions by 13 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?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')


-- TODO:
local m_game = use_sandbox and mw.loadData('Module:Game/sandbox') or mw.loadData('Module:Game')
-- included mods and base items should override the internal values and then set them as semantic properties so items can be queried for
 
-- > subobjects/property in display code
-- Lazy loading
-- drop location (+drop difficulty) support
local f_process_skill_data -- require('Module:Skill').process_skill_data
-- divinatation card support
local f_item_link -- require('Module:Item link').item_link
--
local f_query_area_info -- require('Module:Area').query_area_info
-- TODO: description, stack_size_currency_tab, cosmetic_type
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')
-- 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 v = {}
local c = {}
local g_frame, g_args


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


local h = {}
local h = {}
function h.new_color(label, text)
 
     if text == nil or text == '' then
-- Lazy loading for Module:Skill
        return nil
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
     end
     return tostring(mw.html.create('span')
     return f_process_skill_data(tpl_args)
        :attr('class', 'text-' .. label)
        :wikitext(text))
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
        if func ~= nil then
            value = func(value)
        end
        tr
            :tag('td')
                :wikitext(value)
                :done()
     end
     end
    return f_item_link(args)
end
end


-- ----------------------------------------------------------------------------
-- Lazy loading for Module:Area
-- core
function h.query_area_info(args)
-- ----------------------------------------------------------------------------
     if not f_query_area_info then
 
         f_query_area_info = require('Module:Area').query_area_info
local core = {}
 
function core.validate_mod(args)
    local value = g_args[args.key .. args.i]
    local out = {
        result=nil,
        type=args.key,
        is_text=false,
    }
   
     if value ~= nil then
         --semantic search
        local query = {
            string.format('[[Is mod::%s]]', value),
            '?#=Page',
            '?Is Mod#',
            '?Has mod group#',
            '?Has mod type#',
            '?Has stat text#',
        }
       
        out.result = util.smw.query(query, g_frame)
       
        if out.result == nil or #out.result == 0 then
            error(string.format('Mod "%s" found', value))
        end
       
        out.result = out.result[1]
       
        query = {
            string.format('[[-Has subobject::%s]]', out.result[1]),
            '?Is stat number#',
            '?Has stat id#',
            '?Has minimum stat value#',
            '?Has maximum stat value#',
        }
        out.result.stats = util.smw.query(query, g_frame)
       
        table.insert(g_args._subobjects, {
            ['Is mod number'] = args.i,
            ['Has mod id'] = g_args[value],
        })
       
        -- process and cache stats
        local id, min, max
        for _, stat in ipairs(out.result.stats) do
            id = stat['Has stat id']
            min = tonumber(stat['Has minimum stat value'])
            max = tonumber(stat['Has maximum stat value'])
           
            if g_args._stats[id] == nil then
                g_args._stats[id] = {
                    references = #out+1,
                    min = min,
                    max = max,
                }
            else
                table.insert(g_args._stats[id].references, #out+1)
                g_args._stats[id].min = g_args._stats[id].min + min
                g_args._stats[id].max = g_args._stats[id].max + max
            end
        end
    else
        value = g_args[args.key .. args.i .. '_text']
        if value ~= nil then
            table.insert(g_args._subobjects, {
                ['Is mod number'] = args.i,
                ['Has mod text'] = value,
            })
           
            out.is_text = true
            out.result = value
        end
    end
   
    if out.result ~= nil then
        table.insert(g_args._mods, out)
        return true
    else
        return false
     end
     end
    return f_query_area_info(args)
end
end


function core.err(args)
-- Lazy loading for Module:Item2/cargo
    local err = mw.html.create('div')
function h.append_schema(tpl_args, tables)
     err
     if not f_append_schema then
         :attr('style', 'font-color: red; font-weight: bold;')
         f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
        :wikitext(args.msg or ('Argument ' .. args.key .. ' to item template is invalid. Please check the documention for acceptable values.'))
    end
        :done()
     return f_append_schema(tpl_args, tables)
       
     return tostring(err)
end
end


--
-- Lazy loading for Module:Item2/recipes
-- function factory
function h.process_recipes(tpl_args)
--
     if not f_process_recipes then
core.factory = {}
        f_process_recipes = use_sandbox and require('Module:Item2/recipes/sandbox').process_recipes or require('Module:Item2/recipes').process_recipes
function core.factory.array_table_cast(k, args)
     -- Arguments:
    --
    -- tbl
    -- errmsg
    return function ()
        local elements
       
        if g_args[k] ~= nil then
            elements = util.string.split(g_args[k], ', ')
            for _, element in ipairs(elements) do
                local r = util.table.find_in_nested_array{value=element, tbl=args.tbl, key='full'}
                if r == nil then
                    error(core.err{msg=string.format(args.errmsg, element)})
                end
            end
            g_args[k] = xtable:new(elements)
        end
     end
     end
    return f_process_recipes(tpl_args)
end
end


function core.factory.table_cast(k, args)
function h.handle_range_args(tpl_args, key, field, value, options)
     return function ()
     local opt = {}
        args.value = g_args[k]
    for k, v in pairs(options or {}) do
        g_args[k] = util.table.find_in_nested_array(args)
         opt[k] = v
         if g_args[k] == nil then
            error(core.err{key=k})
        end
     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.stat = {}
function h.stat.add(value, magnitude)
    value.min = value.min + magnitude.min
    value.max = value.max + magnitude.max
end


function core.factory.number_cast(k, default)
function h.stat.add_distance(value, magnitude)
     return function ()
     -- Stats for distance are 10x the display value
        g_args[k] = tonumber(g_args[k]) or default
    value.min = value.min + (magnitude.min / 10)
    end
    value.max = value.max + (magnitude.max / 10)
end
end


function core.factory.boolean_cast(k, default)
function h.stat.increased(value, magnitude)
     return function()
     value.min = value.min * (1 + magnitude.min / 100)
        if g_args[k] == nil then
    value.max = value.max * (1 + magnitude.max / 100)
            g_args[k] = default
        else
            g_args[k] = util.cast.boolean(g_args[k])
        end
    end
end
end


function core.factory.percentage(k)
function h.stat.increased_inverse(value, magnitude)
     return function ()
     value.min = value.min / (1 + magnitude.min / 100)
        local v = tonumber(g_args[k])
    value.max = value.max / (1 + magnitude.max / 100)
       
        if v == nil then
            return core.err{key=k}
        end
       
        if v < 0 or v > 100 then
            return core.err{msg=k .. ' must be in range 0-100.'}
        end
       
        g_args[k] = v
    end
end
end


function core.factory.display_mods(args)
--
    return function ()
-- Processing
        lines = {}
--
       
        for _, modinfo in ipairs(g_args._mods) do
            if modinfo.type == args.type then
                if modinfo.is_text then
                    table.insert(lines, modinfo.result)
                else
                    table.insert(lines, modinfo.result['Has stat text'])
                end
            end
        end
       
        if #lines > 0 and args.type == 'quality' then
            table.insert(lines, h.new_color('default', 'Per 1% Quality:'), 1)
        end
       
        return lines
    end
end


function core.factory.display_value(args)
function h.process_arguments(tpl_args, params)
     -- TODO: sane defaults for the prepend string "before" & after arguments
     tpl_args._processed_args = tpl_args._processed_args or {}
    --
    tpl_args._base_item_args = tpl_args._base_item_args or {}
    -- args:
     for _, k in ipairs(params) do
    --  args<Array>: Array of arguments to use for displaying
         local arg_def = core.map[k]
    --  values<Array>: Array of base values to use for displaying; useful if no args are present
         if arg_def == nil then
    --  options<Array>:
             if tpl_args.debug then
    --  fmt: formatter to use for the value instead of valfmt
                 error(string.format(i18n.debug.invalid_argument_key, k))
    --  allow_zero: allow zero values
    --  before: add this string before the coloured string with colour gray
    --  after: add this string after the coloured string with colour gray
    --  stats_add: Array of stats to add
    --  stats_multiplay: Array of stats to multiply
    --  func: Function to adjust the value with before output
    --  gem_hide_static: function to hide a static value for gem display type
    local _map = {
        add = function (value, stat_cached)
            value.min = value.min + stat_cached.min
            value.max = value.max + stat_cached.max
        end,
        multiply = function (value, stat_cached)
            value.min = value.min * stat_cached.min / 100
            value.max = value.max * stat_cached.max / 100
        end,
    }
   
     for k, default in pairs({stats = {}, options = {}}) do
         if args[k] == nil then
            args[k] = default
         end
    end
   
    local size
    if args.keys ~= nil then
        size = #args.keys
    elseif args.values ~= nil then
        size = #args.values
    end
   
    if size then
        for i=1, size do
             if args.options[i] == nil then
                 args.options[i] = {}
             end
             end
         end
         else
    else
            if arg_def.inherit ~= false then
        error('invalid data')
                table.insert(tpl_args._base_item_args, k)
    end
   
    return function ()
        local values = {}
        local final_values = {}
        if args.type == 'gem' then
            if not core.class_groups.gems.keys:contains(g_args.class) then
                return
             end
             end
             for i, k in ipairs(args.keys) do
             if tpl_args[k] ~= nil and arg_def.deprecated == true then
                local value = g_args['static_' .. k]
                tpl_args._flags.uses_deprecated_parameters = true
                if value ~= nil then
                tpl_args._deprecated_args = tpl_args._deprecated_args or {}
                    if args.options[i].gem_hide_static ~= nil and args.options[i].gem_hide_static(value) then
                 table.insert(tpl_args._deprecated_args, k)
                        return
                    end
                    values[#values+1] = value
                    final_values[#final_values+1] = {value={min=value,max=value}, index=#values}
                 else
                    value = {
                        min=g_args[string.format('level1_%s', k)],
                        max=g_args[string.format('level%s_%s', g_args.max_level, k)],
                    }
                    if value.min ~= nil and value.max ~= nil then
                        values[#values+1] = value.min
                        final_values[#final_values+1] = {value=value, index=#values}
                    end
                end
             end
             end
        else
             if arg_def.func ~= nil then
             if args.values == nil then
                 tpl_args[k] = arg_def.func(tpl_args, tpl_args[k])
                 values = {}
                for i, k in ipairs(args.keys) do
                    local value = g_args[k]
                    if g_args.base_item then
                        value = tonumber(g_args.base_item[core.map[k].property]) or value
                    end
                   
                    values[i] = value
                end
            else
                values = args.values
             end
             end
              
             if tpl_args[k] == nil then
            final_values = {}
                 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
            for i, base_value in ipairs(values) do
                     -- Defaults based on item class
                 local value = {min=base_value, max=base_value}
                    -- 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]
                for _, operator in ipairs({'add', 'multiply'}) do
                elseif arg_def.default ~= nil then
                     local st = args.options[i]['stats_' .. operator]
                    -- General defaults
                    if st ~= nil then
                    if type(arg_def.default) == 'function' then
                        for _, statid in ipairs(st) do
                        tpl_args[k] = arg_def.default(tpl_args)
                            if g_args._stats[statid] ~= nil then
                    else
                                _map[operator](value, g_args._stats[statid])
                         tpl_args[k] = arg_def.default
                            end
                         end
                     end
                     end
                end
               
                local prop = args.options[i].property
               
                if prop ~= nil and not (value.min == 0 and value.max == 0) then
                    g_args._properties[prop .. ' range minimum'] = value.min
                    g_args._properties[prop .. ' range maximum'] = value.max
                    g_args._properties[prop .. ' range avarage'] = (value.min + value.max) / 2
                end
               
                if not (value.min == 0 and value.max == 0 and args.options[i].allow_zero == nil) then
                    table.insert(final_values, {value=value, index=i})
                 end
                 end
             end
             end
            tpl_args._processed_args[k] = true
         end
         end
       
    end
        -- all zeros = dont display and return early
end
        if #final_values == 0 then
 
            return nil
--
        end
-- Display
       
--
        local out = {}
 
       
function h.strip_random_stats(tpl_args, stat_text)
        if args.before then
    if tpl_args._flags.random_mods then
            out[#out+1] = h.new_color('default', args.before)
         repeat
        end
             local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
          
             if text ~= nil then
        for i, data in ipairs(final_values) do
                 stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
             local value = data.value
            local base_value = values[data.index]
            local fmt = args.options[data.index]
           
             if not args.type == 'gem' and (base_value ~= value.min or base_value ~= value.max) then
                 value.color = 'mod'
            else
                value.color = 'value'
             end
             end
              
        until text == nil
             if fmt.func ~= nil then
    end
                 value.min = fmt.func(value.min)
    return stat_text
                 value.max = fmt.func(value.max)
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
             end
           
             if show then
             if fmt.fmt == nil then
                 lines[#lines+1] = line.func(tpl_args)
                 fmt.fmt = '%s'
            elseif type(fmt.fmt) == 'function' then
                fmt.fmt = fmt.fmt()
             end
             end
              
        end
             if value.min == value.max then
        if #lines > 0 then
                 value.out = string.format(fmt.fmt, value.min)
             count = count + 1
            local heading = ''
             if group.heading == nil then
            elseif type(group.heading) == 'function' then
                 heading = group.heading()
             else
             else
                 value.out = string.format(string.format("(%s to %s)", fmt.fmt, fmt.fmt), value.min, value.max)
                 heading = string.format('<em class="header">%s</em><br>', group.heading)
             end
             end
              
             statcont
            value.out = h.new_color(value.color, value.out)
                :tag('span')
           
                    :addClass('group ' .. (group.class or ''))
            local before = ''
                    :wikitext(heading .. table.concat(lines, '<br>'))
            if type(fmt.before) == 'string' then
                    :done()
                before = h.new_color('default', fmt.before)
            elseif type(fmt.before) == 'function' then
                before = h.new_color('default', fmt.before())
            end
           
            local after = ''
            if type(fmt.after) == 'string' then
                after = h.new_color('default', fmt.after)
            elseif type(fmt.after) == 'function' then
                after = h.new_color('default', fmt.after())
            end
           
            out[#out+1] = before .. value.out .. after
        end
       
        if args.after then
            out[#out+1] = h.new_color('default', args.after)
         end
         end
       
        return table.concat(out, ' ')
     end
     end
end


function core.factory.display_value_only(key)
    -- Add groups to infobox
     return function()
     if count > 0 then
        return g_args[key]
        infobox:node(statcont)
     end
     end
end
end


--
function h.make_main_infobox(tpl_args)
-- argument mapping
     local infobox = mw.html.create('span')
--
         :addClass('item-box -' .. tpl_args.frame_type)
core.map = {
    -- special params
    html = {
        property = 'Has infobox HTML',
        func = nil,
    },
    -- generic
    class = {
        property = 'Has item class',
        func = core.factory.table_cast('class', {key='full', tbl=m_game.constants.item.class}),
    },
    rarity = {
        property = 'Has rarity',
        func = core.factory.table_cast('rarity', {key={'full', 'long_lower'}, tbl=m_game.constants.item.rarity, rtrkey='full'}),
    },
    name = {
        property = 'Has name',
        func = nil,
    },
    size_x = {
        property = 'Has inventory width',
        func = core.factory.number_cast('size_x'),
    },
    size_y = {
        property = 'Has inventory height',
        func = core.factory.number_cast('size_y'),
    },
    drop_enabled = {
        property = 'Is drop enabled',
        func = core.factory.boolean_cast('drop_enabled', true),
    },
    drop_level = {
        property = 'Has drop level',
        func = core.factory.number_cast('drop_level'),
    },
    required_level = {
        property = 'Has level requirement',
        func = core.factory.number_cast('required_level'),
    },
    required_dexterity = {
        property = 'Has base dexterity requirement',
        func = core.factory.number_cast('required_dexterity'),
    },
    required_strength = {
        property = 'Has base strength requirement',
        func = core.factory.number_cast('required_strength'),
    },
    required_intelligence = {
        property = 'Has base intelligence requirement',
        func = core.factory.number_cast('required_intelligence'),
    },
    inventory_icon = {
        property = 'Has inventory icon',
        func = function ()
            -- TODO readd support if needed.
            g_args['inventory_icon'] = string.format('File:%s inventory icon.png', g_args.name)  
        end,
     },
    help_text = {
        property = 'Has help text',
        func = nil,
    },
    flavour_text = {
        property = 'Has flavour text',
        func = nil,
    },
    tags = {
        property = 'Has tags',
        func = core.factory.array_table_cast('tags', {
            tbl = m_game.constants.tags,
            errmsg = '%s is not a valid tag',
        }),
    },
    metadata_id = {
         property = 'Has metadata id',
        func = nil,
    },
    -- For rarity != normal, rarity already verified
    base_item = {
        property = 'Has base item',
        func = function ()
            if g_args['rarity'] ~= 'Normal' then
                local query = {
                    string.format('[[Has name::%s]]', g_args['base_item']),
                    string.format('[[Has item class::%s]]', g_args['class']),
                    '[[Has rarity::normal]]',
                }
               
                for _, k in ipairs(g_args['total_args']) do
                    query[#query+1] = string.format('?%s#', core.map[k].property)
                end
               
                local result = util.smw.query(query, g_frame)
               
                if #result > 1 then
                    error(core.err{msg='More then one result found for the specified base item.'})
                    -- TODO be more explicit in the error?
                end
               
                g_args['base_item'] = result
                -- TODO Semantic search - verify ?
            elseif g_args['base_item'] ~= nil then
                error(core.err{msg='Base item requries item with rarity above normal.'})
            end
        end,
    },
    --
    -- specific section
    --
      
      
     -- flasks
     if tpl_args.class_id == 'DivinationCard' then
    charges_max = {
         local divcard = infobox
        property = 'Has base maximum flask charges',
            :tag('span')
         func = core.factory.number_cast('charges_max'),
                :addClass('divicard-wrapper')
    },
         local card_background = tpl_args.card_background or {}
   
        if #card_background > 0 then
    charges_per_use = {
            divcard
        property = 'Has base flask charges per use',
                :tag('span')
         func = core.factory.number_cast('changes_per_use'),
                    :addClass('divicard-background')
    },
                    :wikitext(string.format(
   
                        '[[%s|390px|gif]]',
    flask_mana = {
                        string.format(
        property = 'Has base flask mana recovery',
                            i18n.files.divination_card_background,
        func = core.factory.number_cast('flask_mana'),
                            table.concat(card_background, '-')
    },
                        )
   
                    ))
    flask_life = {
        end
        property = 'Has base flask life recovery',
         divcard
        func = core.factory.number_cast('flask_life'),
            :tag('span')
    },
                :addClass('divicard-art')
   
                :wikitext(string.format('[[%s|link=|alt=]]', tpl_args.card_art))
    flask_duration = {
                :done()
         property = 'Has base flask duration',
            :tag('span')
        func = core.factory.number_cast('flask_duration'),
                :addClass('divicard-frame')
    },
                :done()
   
            :tag('span')
    -- weapons & active skills
                :addClass('divicard-header')
    critical_strike_chance = {
                :wikitext(tpl_args.name)
        property = 'Has base critical strike chance',
                :done()
        func = core.factory.number_cast('critical_strike_chance'),
            :tag('span')
    },
                :addClass('divicard-artlink')
    -- weapons
                :wikitext(string.format('[[%s]]', tpl_args.card_art))
    attack_speed = {
                :done()
        property = 'Has base attack speed',
            :tag('span')
        func = core.factory.number_cast('attack_speed'),
                :addClass('divicard-stack')
    },
                :wikitext(tpl_args.stack_size)
    damage_min = {
                :done()
        property = 'Has base minimum damage',
            :tag('span')
        func = core.factory.number_cast('damage_min'),
                :addClass('divicard-face')
    },
                :tag('span')
    damage_max = {
                    :addClass('divicard-reward')
        property = 'Has base maximum damage',
                    :wikitext(tpl_args.description)
        func = core.factory.number_cast('damage_max'),
                    :done()
    },
                :tag('span')
    range = {
                    :addClass('divicard-flavour')
        property = 'Has base weapon range',
                    :wikitext(tpl_args.flavour_text)
        func = core.factory.number_cast('range'),
                    :done()
    },
     else
    -- armor-type stuff
         local line_type
    armour = {
         local name_line
        property = 'Has base armour',
        if tpl_args._flags.is_derived and tpl_args.rarity_id ~= 'normal' then
        func = core.factory.number_cast('armour', 0),
            line_type = 'double'
    },
            name_line = tpl_args.name .. '<br>' .. tpl_args.base_item
    energy_shield = {
        else
        property = 'Has base energy shield',
            line_type = 'single'
        func = core.factory.number_cast('energy shield', 0),
            name_line = tpl_args.name
    },
        end
    evasion = {
 
        property = 'Has base evasion',
        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        func = core.factory.number_cast('evasion', 0),
         local symbols
    },
         local influences = tpl_args.influences or {}
    -- shields
        if tpl_args.is_replica then
    block = {
            symbols = {'replica', 'replica'}
        property = 'Has base block chance',
            if #influences > 0 then
        func = core.factory.number_cast('block'),
                symbols[2] = influences[1]
    },
    -- 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()
            for _, attr in ipairs(m_game.constants.attributes) do
                local val = g_args[attr.long_lower .. '_percent']
                if val and val >= 60 then
                    g_args['primary_attribute'] = attr.long_upper
                    return
                end
             end
             end
            g_args['primary_attribute'] = 'None'
         elseif #influences > 0 then
         end,
             symbols = {influences[1], influences[1]}
    },
             if #influences > 1 then
    gem_tags = {
                 symbols[2] = influences[2]
        property = 'Has gem tag',
        func = core.factory.array_table_cast('gem_tags', {
             tbl = m_game.constants.item.gem_tags,
            errmsg = '%s is not a valid tag',
        }),
    },
    experience = {
        property = 'Has maximum experience',
        func = core.factory.percentage('experience'),
    },
    skill_screenshot = {
        property = 'Has skill screenshot',
        func = function ()
            g_args.skill_screenshot = string.format('File:%s skill screenshot.jpg', g_args.name)
        end,
    },
    -- Active gems only
    gem_icon = {
        property = 'Has skill gem icon',
        func = function ()
             -- TODO readd support if needed.
            g_args.gem_icon = string.format('File:%s skill icon.png', g_args.name)
        end,
    },
    -- Support gems only
    support_gem_letter_html = {
        property = 'Has support gem letter HTML',
        func = function ()
            if g_args.support_gem_letter == nil then
                 return
             end
             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
          
          
            -- TODO replace this with a loop possibly
        infobox
             local css_map = {
             :tag('span')
                 strength = 'red',
                 :addClass('header -' .. line_type)
                 intelligence = 'blue',
                 :tag('span')
                dexterity = 'green',
                    :addClass('symbol')
            }
                    :addClass(symbols and '-' .. symbols[1] or nil)
            local id
                    :done()
            for k, v in pairs(css_map) do
                :wikitext(name_line)
                 k = string.format('%s_percent', k)
                 :tag('span')
                if g_args[k] and g_args[k] > 50 then
                    :addClass('symbol')
                     id = v
                    :addClass(symbols and '-' .. symbols[2] or nil)
                    break
                     :done()
                end
             :done()
             end
              
              
            if id ~= nil then
        h.add_to_infobox_from_map(tpl_args, infobox, c.item_infobox_groups)
                local container = mw.html.create('span')
    end
                container
      
                    :attr('class', string.format('support-gem-id-%s', id))
     if tpl_args.skill_icon ~= nil then
                    :wikitext(g_args.support_gem_letter)
         infobox:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
                    :done()
     end
                g_args.support_gem_letter_html = tostring(container)
            end
        end,
     },
     -- Maps
    map_level = {
         property = 'Has map level',
        func = core.factory.number_cast('map_level'),
    },
    -- TODO: aren't these given by mods ... removeable?
    map_item_quantity = {
        property = 'Has base map item quantity',
        func = core.factory.number_cast('map_item_quantity'),
    },
    map_item_rarity = {
        property = 'Has base map item rarity',
        func = core.factory.number_cast('map_item_rarity'),
    },
    map_pack_size = {
        property = 'Has base map pack size',
        func = core.factory.number_cast('map_pack_size'),
    },
    -- 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,
    },
      
      
}
    return infobox
end


-- base item is default, but will be validated later
--  
core.default_args = {'class', 'rarity', 'name', 'size_x', 'size_y', 'drop_enabled', 'drop_level', 'required_level', 'required_dexterity', 'required_intelligence', 'required_strength', 'inventory_icon', 'flavour_text', 'help_text', 'tags', 'metadata_id'}
-- Factory
core.class_groups = {
--
    flasks = {
        keys = xtable:new({'Life Flasks', 'Mana Flasks', 'Hybrid Flasks', 'Utility Flasks', 'Critical Utility Flasks'}),
        args = {'flask_duration', 'charges_max', 'charges_per_use'},
    },
    weapons = {
        keys = xtable:new({'Claws', 'Daggers', 'Wands', 'One Hand Swords', 'Thrusting One Hand Swords', 'One Hand Axes', 'One Hand Maces', 'Bows', 'Staves', 'Two Hand Swords', 'Two Hand Axes', 'Two Hand Maces', 'Sceptres'}),
        args = {'critical_strike_chance', 'attack_speed', 'damage_min', 'damage_max', 'range'},
    },
    gems = {
        keys = xtable:new({'Active Skill Gems', 'Support Skill Gems'}),
        args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'primary_attribute', 'gem_tags'},
    },
    armor = {
        keys = xtable:new({'Gloves', 'Boots', 'Body Armours', 'Helmets', 'Shields'}),
        args = {'armour', 'energy_shield', 'evasion'},
    },
    stackable = {
        keys = xtable:new({'Currency', 'Stackable Currency', 'Hideout Doodads', 'Microtransactions', 'Divination Card'}),
        args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
    },
}


core.class_specifics = {
h.factory = {}
    ['Life Flasks'] = {
        args = {'flask_life'},
    },
    ['Mana Flasks'] = {
        args = {'flask_mana'},
    },
    ['Hybrid Flasks'] = {
        args = {'flask_life', 'flask_mana'},
    },
    ['Active Skill Gems'] = {
        args = {'skill_screenshot', 'gem_icon'},
        defaults = {
            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,
        },
    },
    ['Support Skill Gems'] = {
        args = {'support_gem_letter_html'},
        defaults = {
            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.',
            size_x = 1,
            size_y = 1,
        },
    },
    ['Shields'] = {
        args = {'block'},
    },
    ['Hideout Doodads'] = {
        defaults = {
            help_text = 'Right click on this item then left click on a location on the ground to create the object.',
        },
    },
    ['Jewel'] = {
        defaults = {
            help_text = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
        },
    },
}


-- add defaults from class specifics and class groups
function h.factory.maybe_show_infobox_line(args)
core.item_classes = {}
    -- Verifies that a list of keys are present in tpl_args and that the item
for _, data in ipairs(m_game.constants.item.class) do
    -- should use those keys. Returns true if all conditions are met, otherwise
    core.item_classes[data['full']] = {
    -- returns false.
         args = xtable:new(),
    return function (tpl_args)
         defaults = {},
        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
end


for _, row in pairs(core.class_groups) do
function h.factory.display_raw_value(key)
     for _, k in ipairs(row.keys) do
     return function(tpl_args)
         core.item_classes[k].args:insertT(row.args)
         return tpl_args[key]
     end
     end
end
end


 
function h.factory.descriptor_value(args)
for k, row in pairs(core.class_specifics) do
    -- Arguments:
    if row.args ~= nil then
    --  key
         core.item_classes[k].args:insertT(row.args)
    --  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
    if row.defaults ~= nil then
        for key, value in pairs(row.defaults) do
            core.item_classes[k].defaults[key] = value
        end
  end
end
end


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


-- GroupTable -> RowTable -> formatter function
--
--
-- Contents here are meant to resemble the ingame infobox of items
--
--
core.display_groups = {
c.item_infobox_groups = {
     -- Tags, stats, level, etc
     -- [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
         {
         {
             args = {'gem_tags'},
             show = h.factory.maybe_show_infobox_line{
             func = function ()
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
             func = function (tpl_args)
                 local out = {}
                 local out = {}
                 for i, tag in ipairs(g_args.gem_tags) do
                 for i, tag in ipairs(tpl_args.gem_tags) do
                     out[#out+1] = string.format('[[:Category:%s (gem tag)|%s]]', tag, tag)
                     out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                 end
                 end
               
                 return table.concat(out, ', ')
                 return table.concat(out, ', ')
             end,
             end,
         },
         },
         {
         {
             args = {'support_gem_letter_html'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'support_gem_letter_html'},
                keys={'support_gem_letter_html'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         --property = 'Has support gem letter HTML',
                 parts = {
                         before = 'Icon: ',
                     {
                         key = 'support_gem_letter_html',
                         color = false,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.support_icon,
             },
             },
         },
         },
         {
         {
             args = {'radius'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
                 keys={'radius'},
            end,
                 options = {
            func = function (tpl_args)
                     [1] = {
                local value = {
                         --property = 'Has radius',
                    base = 1,
                         before = 'Radius: ',
                    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,
             },
             },
         },
         },
        -- TODO: gem level here. Maybe put max level here?
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has cost_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'mana_cost'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'cost_multiplier',
                         --property = 'Has mana cost',
                        hide_default = 100,
                         fmt = function ()
                         fmt = '%i',
                            if g_args.has_percentage_mana_cost then
                         inline = '%s%%',
                                return '%i%%'
                            else
                                return '%i'
                            end
                        end,
                         before = function ()
                            if g_args.has_reservation_mana_cost then
                                return 'Mana Reserved: '
                            else
                                return 'Mana Cost: '
                            end
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.cost_multiplier,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has cooldown
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'mana_multiplier'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'cooldown',
                         --property = 'Has mana multiplier',
                         hide_default = 0,
                         fmt = '%i%%',
                         fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                         before = 'Mana Multiplier: ',
                        gem_hide_static=function (value)
                            if value == 100 then
                                return true
                            end
                            return false
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.cooldown_time,
             },
             },
         },
         },
         {
         {
             args = nil,
             -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
             func = core.factory.display_value{
            show = true,
                keys={'vaal_souls_requirement', 'vaal_souls_requirement', 'vaal_souls_requirement'},
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 options = {
                 parts = {
                    [1] = {
                     {
                        --property = 'Has normal souls requirement',
                         key = 'stored_uses',
                        fmt = '%i (N) / ',
                         hide_default = 0,
                        before = 'Souls per use: ',
                         fmt = '%i',
                     },
                    [2] = {
                         fmt = '%i (C) / ',
                         func = function (value)
                            return value*1.5
                        end,
                    },
                    [3] = {
                         fmt = '%i (M)',
                        func = function (value)
                            return value*2
                        end,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.stored_uses,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has vaal_souls_requirement
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'vaal_stored_uses'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'vaal_souls_requirement',
                         --property = 'Has stored uses',
                        hide_default = 0,
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Can store ',
                        after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.vaal_souls_per_use,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has vaal_stored_uses
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'stored_uses'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'vaal_stored_uses',
                         --property = 'Has stored uses',
                        hide_default = 0,
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Can store ',
                        after = ' use(s)',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'cooldown'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'vaal_soul_gain_prevention_time',
                         --property = 'Has cooldown time',
                         hide_default = 0,
                         fmt = '%.2f sec',
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data,  
                         before = 'Cooldown Time: ',
                         fmt = '%i ' .. m_game.units.seconds.short_lower,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
             },
             },
         },
         },
         {
         {
             args = {'cast_time'},
             show = function (tpl_args)
             func = core.factory.display_value{
                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))
                 keys={'cast_time'},
            end,
                 options = {
            func = function (tpl_args)
                     [1] = {
                return core.factory.infobox_line{
                         --property = 'Has cast time',
                    parts = {
                         fmt = '%.2f sec',
                        {
                        before = 'Cast Time: ',
                            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,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has critical_strike_chance
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                keys={'critical_strike_chance'},
                 type = 'gem',
                 type='gem',
                 parts = {
                 options = {
                     {
                     [1] = {
                         key = 'critical_strike_chance',
                         property = 'Has critical strike chance',
                        hide_default = 0,
                         fmt = '%.2f%%',
                         fmt = '%.2f%%',
                        before = 'Critical Strike Chance: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.critical_strike_chance,
             },
             },
         },
         },
         {
         {
             args = nil,
             show = true, -- TODO: Show only if has attack_speed_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 type='gem',
                 type = 'gem',
                 keys={'damage_effectiveness'},
                 parts = {
                options = {
                     {
                     [1] = {
                         key = 'attack_speed_multiplier',
                         --property = 'Has damage effectiveness',
                        hide_default = 100,
                         fmt = '%i%%',
                         fmt = '%i',
                         before = 'Damage Effectiveness: ',
                         inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.attack_speed_multiplier,
             },
             },
         },
         },
        -- Weapon only
         {
         {
             args = {'damage_min', 'damage_max'},
             show = true, -- TODO: Show only if has damage_multiplier
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 keys={'damage_min', 'damage_max'},
                 type = 'gem',
                 options = {
                 parts = {
                     [1] = {
                     {
                         property = 'Has minimum physical damage',
                         key = 'damage_multiplier',
                         fmt = '%i&ndash;',
                         hide_default = 100,
                         stats_add = {
                         fmt = '%i',
                            'local_minimum_added_physical_damage',
                         inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                         },
                        stats_multiply = {
                            'local_physical_damage_+%',
                        },
                        before = 'Physical Damage: '
                     },
                     },
                     [2] = {
                },
                         property = 'Has maximum physical damage',
                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',
                         fmt = '%i',
                         stats_add = {
                         inline = '%s%%',
                            'local_maximum_added_physical_damage',
                        },
                        stats_multiply = {
                            'local_physical_damage_+%',
                        },
                     },
                     },
                 },
                 },
             },      
                fmt = i18n.tooltips.damage_effectiveness,
             },
         },
         },
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'projectile_speed'},
                 before='Elemental Damage: ',
            },
                values={0, 0, 0, 0, 0, 0},
            func = core.factory.infobox_line{
                 options = {
                 parts = {
                     [1] = {
                     {
                         property = 'Has minimum fire damage',
                         key = 'projectile_speed',
                        fmt = '%i',
                        before = '<span class="text-fire">',
                        stats_add = {
                            'local_minimum_added_fire_damage',
                        },
                     },
                     },
                    [2] = {
                },
                        property = 'Has maximum fire damage',
                fmt = i18n.tooltips.projectile_speed,
                        fmt = '%i',
            },
                         after = '</span>',
        },
                         stats_add = {
        {
                            'local_maximum_added_fire_damage',
            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'},
                     },
                     },
                     [3] = {
                     {
                         property = 'Has minimum cold damage',
                         key = 'radius_secondary',
                         fmt = '%i',
                         func = h.factory.descriptor_value{key='radius_secondary_description'},
                        before = '<span class="text-cold">',
                        stats_add = {
                            'local_minimum_added_cold_damage',
                        },
                     },
                     },
                     [4] = {
                     {
                         property = 'Has maximum cold damage',
                         key = 'radius_tertiary',
                         fmt = '%i',
                         func = h.factory.descriptor_value{key='radius_tertiary_description'},
                        after = '</span>',
                        stats_add = {
                            'local_maximum_added_cold_damage',
                        },
                     },
                     },
                    [5] = {
                },
                        property = 'Has minimum lightning damage',
                sep = ' / ',
                         fmt = '%i',
                fmt = i18n.tooltips.aoe_radius,
                         before = '<span class="text-lightning">',
            },
                         stats_add = {
        },
                            'local_minimum_added_lightning_damage',
        -- 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,
                     },
                     },
                    [6] = {
                },
                        property = 'Has maximum lightning damage',
                fmt = i18n.tooltips.quality,
                        fmt = '%i',
            },
                        after = '</span>',
        },
                        stats_add = {
        -- Weapons
                            'local_maximum_added_lightning_damage',
        {
                         },
            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,
             },       
             },       
         },
         },
         {
         {
             args = nil,
             show = true, -- Elemental Damage
             func = core.factory.display_value{
             func = function (tpl_args)
                 before='Chaos Damage: ',
                 local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                 values={0,0},
                 local elements = {}
                 options = {
                 for _, key in ipairs(keys) do
                     [1] = {
                     if tpl_args[key] then
                        property = 'Has minimum chaos damage',
                        elements[#elements+1] = tpl_args[key]
                        fmt = '%i',
                    end
                        stats_add = {
                end
                            'local_minimum_added_chaos_damage',
                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
                     },
                     },
                    [2] = {
                },
                        property = 'Has maximum chaos damage',
                fmt = i18n.tooltips.chaos_damage,
                        fmt='%i',
            },     
                        stats_add = {
        },
                            'local_maximum_added_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,
             },
         },
         },
         {
         {
             args = {'critical_strike_chance'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'attack_speed_html'},
                keys={'critical_strike_chance'},
            },
                 options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         property = 'Has critical strike chance',
                     {
                         fmt = '%.2f%%',
                         key = 'attack_speed_html',
                        before = 'Critical Strike Chance: ',
                         color = false, -- html already has color
                        stats_add = {
                            'local_critical_strike_chance',
                        },
                        stats_multiply = {
                            'local_critical_strike_chance_+%',
                        },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.attacks_per_second,
             },
             },
         },
         },
         {
         {
             args = {'attack_speed'},
             show = function (tpl_args)
            func = core.factory.display_value{
                -- Do not show for ranged weapons
                keys={'attack_speed'},
                if tpl_args.tags and m_util.table.contains(tpl_args.tags, 'ranged') then
                 options = {
                    return false
                    [1] = {
                end
                        property = 'Has attack speed',
                return h.factory.maybe_show_infobox_line{
                         fmt = '%.2f',
                    keys = {'weapon_range_html'},
                         before = 'Attacks per Second: ',
                 }(tpl_args)
                         stats_multiply = {
            end,
                            'local_attack_speed_+%',
            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,
             },
             },
         },
         },
         -- Map only
         -- Maps
         {
         {
             args = {'map_level'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'map_area_level'},
                keys={'map_level'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         --property = 'Has map level',
                 parts = {
                     {
                         key = 'map_area_level',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Map Level: ',
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.map_level,
             },
             },
         },
         },
         {
         {
             args = {'map_item_quantity'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'map_tier'},
                keys={'map_item_quantity'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has map item quantity',
                 parts = {
                     {
                         key = 'map_tier',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Item Quantity: ',
                        stats_add = {
                            'map_item_drop_quantity_+%',
                        },
                     },
                     },
                 },
                 },
                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,
             },
             },
         },
         },
         {
         {
             args = {'map_item_rarity'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
                 keys={'map_item_rarity'},
            end,
                 options = {
             func = core.factory.infobox_line{
                     [1] = {
                 type = 'stat',
                         property = 'Has map item rarity',
                 parts = {
                     {
                         key = 'map_item_drop_quantity_+%',
                         fmt = '%i',
                         fmt = '%i',
                         before = 'Item Rarity: ',
                         color = 'mod',
                         stats_add = {
                         inline = '+%s%%',
                            'map_item_drop_rarity_+%',
                         hide_default = 0,
                         },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.item_quantity,
             },
             },
         },
         },
         {
         {
             args = {'map_pack_size'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
                 keys={'map_pack_size'},
            end,
                 options = {
             func = core.factory.infobox_line{
                     [1] = {
                 type = 'stat',
                         property = 'Has map pack size',
                 parts = {
                     {
                         key = 'map_item_drop_rarity_+%',
                         fmt = '%i',
                         fmt = '%i',
                         before = 'Pack Size: ',
                         color = 'mod',
                         stats_add = {
                         inline = '+%s%%',
                            'map_pack_size_+%',
                         hide_default = 0,
                         },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.item_rarity,
             },
             },
         },
         },
        -- Jewel Only
         {
         {
             args = {'limit'},
             show = function (tpl_args)
             func = core.factory.display_value{
                return tpl_args.class_id == 'Map'
                 keys={'limit'},
            end,
                 options = {
             func = core.factory.infobox_line{
                     [1] = {
                 type = 'stat',
                         --property = 'Has limit',
                 parts = {
                     {
                         key = 'map_pack_size_+%',
                         fmt = '%i',
                         fmt = '%i',
                         before = 'Limit: ',
                         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,
             },
             },
         },
         },
         {
         {
             args = {'jewel_radius'},
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'jewel_radius_html'},
                 keys={'jewel_radius'},
                 conditions = {processed = true},
                 options = {
            },
                    [1] = {
            func = core.factory.infobox_line{
                        --property = 'Has jewel radius',
                parts = {
                         fmt = '%i',
                    {
                         before = 'Radius: ',
                         key = 'jewel_radius_html',
                         color = false, -- html already has color
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.radius,
             },
             },
         },
         },
         -- Flask only
         -- Flasks
         {
         {
             args = {'flask_mana', 'flask_duration'},
             show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
             --func = core.factory.display_flask('flask_mana'),
             --func = core.factory.display_flask('flask_mana'),
             func = core.factory.display_value{
             func = core.factory.infobox_line{
                 keys = {'flask_mana', 'flask_duration'},
                 parts = {
                options = {
                     {
                     [1] = {
                         key = 'flask_mana_html',
                         property = 'Has flask mana recovery',
                         color = false, -- html already has color
                         fmt = '%i Mana',
                        before = 'Recovers',
                        stats_add = {
                            'local_flask_mana_to_recover',
                        },
                        stats_multiply = {
                            'local_flask_mana_to_recover_+%',
                        },
                     },
                     },
                     [2] = {
                     {
                         property = 'Has flask duration',
                         key = 'flask_duration_html',
                        fmt = '%.2f',
                         color = false, -- html already has color
                        before = ' over ',
                         after = ' seconds',
                        stats_multiply = {
                            'local_flask_recovery_speed_+%',
                        },
                     },
                     },
                 }
                 },
                fmt = i18n.tooltips.flask_mana_recovery,
             },
             },
         },
         },
         {
         {
             args = {'flask_life', 'flask_duration'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'flask_life_html', 'flask_duration_html'},
                 keys = {'flask_life', 'flask_duration'},
            },
                options = {
             func = core.factory.infobox_line{
                     [1] = {
                 parts = {
                         property = 'Has flask mana recovery',
                     {
                         fmt = '%i Life',
                         key = 'flask_life_html',
                        before = 'Recovers',
                         color = false, -- html already has color
                        stats_add = {
                            'local_flask_life_to_recover',
                        },
                        stats_multiply = {
                            'local_flask_life_to_recover_+%',
                        },
                     },
                     },
                     [2] = {
                     {
                         property = 'Has flask duration',
                         key = 'flask_duration_html',
                        fmt = '%.2f',
                         color = false, -- html already has color
                        before = ' over ',
                         after = ' seconds',
                        stats_multiply = {
                            'local_flask_recovery_speed_+%',
                        },
                     },
                     },
                 }
                 },
                fmt = i18n.tooltips.flask_life_recovery,
             },
             },
         },
         },
         {
         {
             -- don't display for mana/life flasks
             -- don't display for mana/life flasks
             args = function ()
             show = function (tpl_args)
                 for _, k in ipairs({'flask_life', 'flask_mana'}) do
                 for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                     if g_args[k] ~= nil then
                     if tpl_args[k] ~= nil then
                         return false
                         return false
                     end
                     end
                 end
                 end
               
                 return tpl_args['flask_duration_html'] ~= nil
                 return g_args['flask_duration'] ~= 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,
             end,
             func = core.factory.display_value{
        },
                 keys = {'flask_duration'},
        {
                 options = {
             show = h.factory.maybe_show_infobox_line{
                     [1] = {
                 keys = {'seed_type_html'},
                         property = 'Has flask duration',
                 conditions = {processed = true},
                         before = 'Lasts ',
            },
                         after = ' Seconds',
            func = core.factory.infobox_line{
                        fmt = '%.2f',
                parts = {
                        stats_multiply = {
                     {
                            'local_flask_recovery_speed_+%',
                         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
         {
         {
             args = {'charges_per_use', 'charges_cap'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'sentinel_duration'},
                 keys = {'charges_per_use', 'charges_cap'},
                conditions = {processed = true},
                options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has flask charges per use',
                 parts = {
                        before = 'Consumes ',
                     {
                         key = 'sentinel_duration',
                         fmt = '%i',
                         fmt = '%i',
                        stats_multiply = {
                            'local_charges_used_+%',
                        },
                     },
                     },
                    [2] = {
                },
                        property = 'Has flask maximum charges',
                fmt = i18n.tooltips.sentinel_duration,
                        before = ' of ',
            },
                         after = ' Charges on use',
        },
        {
            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 = '%i',
                        stats_add = {
                            'local_extra_max_charges',
                        },
                        stats_multiply = {
                            'local_max_charges_+%',
                            'local_charges_added_+%',
                        },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.sentinel_empowers,
             },
             },
         },
         },
        -- armor
         {
         {
             args = {'block'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'sentinel_empowerment'},
                keys={'block'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has block',
                 parts = {
                     {
                         key = 'sentinel_empowerment',
                         fmt = '%i',
                         fmt = '%i',
                        stats_add = {
                            'local_additional_block_chance_%',
                        },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.sentinel_empowerment,
             },
             },
         },
         },
         {
         {
             args = {'armour'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'sentinel_monster', 'sentinel_monster_level'},
                 keys={'armour'},
                conditions = {processed = true},
                options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has armour',
                 parts = {
                    {
                        key = 'sentinel_monster',
                    },
                     {
                         key = 'sentinel_monster_level',
                         fmt = '%i',
                         fmt = '%i',
                        stats_add = {
                            'local_base_physical_damage_reduction_rating',
                        },
                        stats_multiply = {
                            'local_physical_damage_reduction_rating_+%',
                            'local_armour_and_energy_shield_+%',
                            'local_armour_and_evasion_+%',
                            'local_armour_and_evasion_and_energy_shield_+%',
                        },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.sentinel_can_only_empower,
             },
             },
         },
         },
         {
         {
             args = {'evasion'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'sentinel_charge'},
                keys={'evasion'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has evasion',
                 parts = {
                     {
                         key = 'sentinel_charge',
                         fmt = '%i',
                         fmt = '%i',
                         stats_add = {
                    },
                            'local_base_evasion_rating',
                },
                         },
                fmt = i18n.tooltips.sentinel_charge,
                        stats_multiply = {
            },
                            'local_evasion_rating_+%',
        },
                             'local_evasion_and_energy_shield_+%',
        -- Corpse items
                             'local_armour_and_evasion_+%',
        {
                             'local_armour_and_evasion_and_energy_shield_+%',
            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
         {
         {
             args = {'energy_shield'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'tattoo_min_adjacent'},
                keys={'energy_shield'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         property = 'Has energy shield',
                 parts = {
                     {
                         key = 'tattoo_min_adjacent',
                         fmt = '%i',
                         fmt = '%i',
                         stats_add = {
                         hide_default = 0,
                            'local_energy_shield'
                        },
                        stats_multiply = {
                            'local_energy_shield_+%',
                            'local_armour_and_energy_shield_+%',
                            'local_evasion_and_energy_shield_+%',
                            'local_armour_and_evasion_and_energy_shield_+%',
                        },
                     },
                     },
                 },
                 },
                fmt = i18n.tooltips.tattoo_min_adjacent,
             },
             },
         },
         },
        -- Misc
         {
         {
             args = {'stack_size'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value{
                keys = {'tattoo_max_adjacent'},
                keys={'stack_size'},
                conditions = {processed = true},
                 options = {
            },
                     [1] = {
             func = core.factory.infobox_line{
                         --property = 'Has stack size',
                 parts = {
                     {
                         key = 'tattoo_max_adjacent',
                         fmt = '%i',
                         fmt = '%i',
                         before = 'Stack Size: ',
                         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'),
         },
         },
     },
     },
     -- Requirements
     -- Gem stats
     {
     {
        class = 'tc -mod',
         {
         {
             args = function ()
             show = function (tpl_args)
                 if g_args.drop_enabled == true then
                 return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
                     return false
            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
                 end
                 return true
                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,
             end,
             func = function()
             func = core.factory.infobox_line{
                 local span = mw.html.create('span')
                 parts = {
                 span
                    {
                    :attr('class', 'infobox-disabled-drop')
                        key = 'quality_type1_stat_text',
                    :wikitext('DROP DISABLED')
                        color = 'mod',
                     :done()
                        inline = i18n.tooltips.gem_quality_effect_bonus,
                 return tostring(span)
                        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,
             end,
         },
         },
         -- Instead of item level, show drop level if any
    },
    -- Explicit stats
    {
         class = 'tc -mod',
         {
         {
             args = function ()
             show = h.factory.maybe_show_infobox_line{
                 if g_args.drop_enabled == false then
                keys = {'explicit_stat_text'},
                     return false
            },
            func = function (tpl_args)
                 if tpl_args._infobox_container == 'inline' then
                     return h.strip_random_stats(tpl_args, tpl_args.explicit_stat_text)
                 end
                 end
               
                 return tpl_args.explicit_stat_text
                 return g_args.drop_level ~= nil
             end,
             end,
             func = core.factory.display_value{
        },
                 keys={'drop_level'},
    },
                 options = {
    -- Experience
                     [1] = {
    --[[{
        {
             show = h.factory.maybe_show_infobox_line{
                 keys = {'experience'},
            },
            func = core.factory.infobox_line{
                 parts = {
                     {
                        key = 'experience',
                         fmt = '%i',
                         fmt = '%i',
                        before = 'Drop Level: ',
                     },
                     },
                 },
                 },
             },
             },
         },
         },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
         {
         {
             args = nil,
             show = h.factory.maybe_show_infobox_line{
            func = function ()
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                 local requirements = {}
                 conditions = {processed = true},
                local attr_label
            },
                local use_short_label
            func = function (tpl_args)
               
                 if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                 if g_args.required_level 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))
                     table.insert( requirements, 'Level ' .. tostring( h.new_color('value', g_args.required_level) ) )
                 end
                 end
               
            end
                for _, attr in ipairs(m_game.constants.attributes) do
        },
                    local val = g_args['required_' .. attr['long_lower']]
        {
                    if val then
            show = h.factory.maybe_show_infobox_line{
                        use_short_label = false or g_args.required_level
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                        for _, attr2 in ipairs(m_game.constants.attributes) do
                conditions = {processed = true},
                            if attr ~= attr2 then
            },
                                use_short_label = use_short_label or g_args[attr2['long_lower']]
            func = function (tpl_args)
                            end
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                        end
                    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))
                        if use_short_label then
                            attr_label = attr['short_upper']
                        else
                            attr_label = attr['long_upper']
                        end
                        table.insert( requirements, h.new_color('value', val) .. ' ' .. attr_label )
                    end
                 end
                 end
                  
            end
                 -- return early
        },
                 if #requirements == 0 then
        {
                     return
            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
                  
            end
                 return h.new_color('default', 'Requires ') .. table.concat(requirements, ', ')
        },
             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'),
         },
         },
     },
     },
     -- Gem description
     -- Description
     {
     {
         css_class = 'textwrap text-gemdesc',
         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,
            },
        },]]
         {
         {
             args = {'gem_description'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('gem_description'),
                keys = {'monster_abilities'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('monster_abilities'),
         },
         },
     },
     },
     -- Gem Quality Stats
     -- Variations (for hideout decorations)
     {
     {
         css_class = 'textwrap text-mod',
         class = 'tc -mod',
         {
         {
             args = {'quality_stat_text'},
             show = h.factory.maybe_show_infobox_line{
             func = function ()
                keys = {'variation_count'},
                 lines = {}
                conditions = {processed = true},
                lines[#lines+1] = h.new_color('default', 'Per 1% Quality:')
            },
                 lines[#lines+1] = g_args.quality_stat_text
             func = function (tpl_args)
               
                 if tpl_args.variation_count > 1 then
                 return table.concat(lines, '<br>')
                    return string.format('%i %s', tpl_args.variation_count, i18n.tooltips.variations)
                 end
                 return nil
             end,
             end,
         },
         },
     },
     },
     -- Gem Implicit Stats
     -- Corrupted
     {
     {
         css_class = 'textwrap text-mod',
         class = 'tc -corrupted',
         {
         {
             args = {'stat_text'},
             show = h.factory.maybe_show_infobox_line{
             func = function ()
                keys = {'is_corrupted'},
                lines = {}
                conditions = {processed = true},
                lines[#lines+1] = g_args.stat_text
            },
                 if g_args.gem_tags:contains('Vaal') then
             func = function (tpl_args)
                     lines[#lines+1] = h.new_color('corrupted', 'Corrupted')
                 if tpl_args.is_corrupted then
                     return i18n.tooltips.corrupted
                 end
                 end
                 return table.concat(lines, '<br>')
                 return nil
             end,
             end,
         },
         },
     },
     },
     -- Quality Stats
     -- Mirrored
     {
     {
         css_class = 'text-mod',
         class = 'tc -mod',
         func = core.factory.display_mods{type='quality'},
         {
            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,
        },
     },
     },
     -- Implicit Stats
     -- Unmodifiable
     {
     {
         css_class = 'text-mod',
         class = 'tc -mod',
         func = core.factory.display_mods{type='implicit'},
         {
            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,
        },
     },
     },
     -- Stats
     -- Flavour text
     {
     {
         css_class = 'text-mod',
         class = 'tc -flavour',
         func = core.factory.display_mods{type='mod'},
         {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
     },
     },
     -- Experience
     -- Prophecy text
     {
     {
        class = 'tc -value',
         {
         {
             args = {'experience'},
             show = h.factory.maybe_show_infobox_line{
            func = core.factory.display_value{
                 keys = {'prediction_text'},
                 keys={'experience'},
                 conditions = {processed = true},
                 options = {
                    [1] = {
                        fmt = '%i',
                    },
                },
             },
             },
            func = h.factory.display_raw_value('prediction_text'),
         },
         },
     },
     },
     -- Flavour Text
     -- Can not be traded or modified
     {
     {
         css_class = 'textwrap text-flavour',
         class = 'tc -canttradeormodify',
         {
         {
             args = {'flavour_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('flavour_text'),
                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
     -- Help text
     {
     {
         css_class = 'textwrap text-help',
         class = 'tc -help',
         {
         {
             args = {'help_text'},
             show = h.factory.maybe_show_infobox_line{
             func = core.factory.display_value_only('help_text'),
                keys = {'help_text'},
                conditions = {processed = true},
            },
             func = h.factory.display_raw_value('help_text'),
         },
         },
     },
     },
     -- Cost (i.e. vendor costs)
     -- 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,
        },
     },
     },
}
}


core.item_link_params = {'name', 'inventory_icon', 'html'}
--
core.item_link_broken_cat = '[[Category:Pages with broken item links]]'
-- This is meant to show additional information about the item in a separate infobox
 
--
core.result = {}
c.extra_display_groups = {
 
core.result.skill_gem = {
     {
     {
         arg = 'icon',
         heading = i18n.tooltips.extra_info,
         header = util.html.abbr('L', 'Support gem letter.'),
        class = '',
        property = 'Has support gem letter HTML',
         {
        cast = nil,
            show = h.factory.maybe_show_infobox_line{
        display = h.na_or_val,
                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
     {
     {
         arg = 'skill_icon',
         heading = i18n.tooltips.acquisition,
         header = 'Icon',
         {
         property = 'Has skill gem icon',
            show = function (tpl_args)
         cast = nil,
                if tpl_args.is_in_game == false then
         display = function (tr, value)
                    return true
             return h.na_or_val(tr, value, function(value)
                end
                 return string.format('[[%s]]', value)
                return false
             end)
            end,
         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,
            },
        },
     },
     },
     {
     {
         arg = 'description',
         -- Vendor prices
        header = 'Description',
        heading = i18n.tooltips.purchase_costs,
        property = 'Has description',
        {
        cast = nil,
            show = function (tpl_args)
         display = h.na_or_val,
                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,
         },
     },
     },
     {
     {
         arg = 'level',
         -- Vendor offer
         header = m_game.level_requirement.icon,
        heading = i18n.tooltips.sell_price,
        property = 'Has level requirement',
         {
        cast = tonumber,
            show = h.factory.maybe_show_infobox_line{
        display = h.na_or_val,
                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
     {
     {
         arg = 'crit',
         heading = i18n.tooltips.damage_per_second,
         header = util.html.abbr('Crit', 'Critical Strike Chance'),
        {
         property = 'Has critical strike chance',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'physical_dps_html'},
         display = function (tr, value)
            },
             return h.na_or_val(tr, value, function(value)
            func = core.factory.infobox_line{
                 return string.format('%s%%', value)
                parts = {
             end)
                    {
         end,
                        key = 'physical_dps_html',
    },  
                        color = false, -- the html already contains the colour
    {
                    },
        arg = 'mcm',
                },
         header = util.html.abbr('MCM', 'Mana cost multiplier - missing values indicate it changes on gem level'),
                fmt = i18n.tooltips.physical_dps,
        property = 'Has mana multiplier',
            },
         cast = tonumber,
        },
         display = h.na_or_val,
         {
            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
     {
     {
         arg = 'vaal',
         heading = i18n.tooltips.metadata,
         header = util.html.abbr('Souls', 'Vaal souls requirement in Normal/Cruel/Merciless difficulty'),
         {
        property = 'Has vaal souls requirement',
            show = h.factory.maybe_show_infobox_line{
        cast = tonumber,
                keys = {'class'},
         display = function (tr, value)
                conditions = {processed = true},
             return h.na_or_val(tr, value, function (value)
            },
                 return string.format('%d / %d / %d', value, value*1.5, value*2)
            func = core.factory.infobox_line{
             end)
                parts = {
        end,
                    {
    },
                        key = 'class',
    {
                    },
        arg = 'vaal',
                },
        header = util.html.abbr('Uses', 'Maximum number of stored uses'),
                fmt = i18n.tooltips.item_class,
        property = 'Has vaal stored uses',
            },
        cast = tonumber,
         },
         display = h.na_or_val,
        {
             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,
         },
     },
     },
}
}
for _, attr in ipairs(m_game.constants.attributes) do
    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
-- Subroutines
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


--
local s = {}
-- Frame args:
 
-- class
-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.
-- rarity
 
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'})


function p.itembox (frame)
     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
     -- Args/Frame
        if row.keys[tpl_args.class_id] then
    --
            for _, k in ipairs(extend_keys) do
    local t = os.clock()
                if row[k] then
   
                    for _, v in ipairs(row[k]) do
    g_args = getArgs(frame, {
                        table.insert(config[k], v)
        parentFirst = true
                    end
    })
                end
    g_frame = util.misc.get_frame(frame)
            end
   
            if row['defaults'] then
    --
                for k, v in pairs(row['defaults']) do
    -- Shared args
                    config['defaults'][k] = v
    --
                end
   
            end
     g_args._total_args = {}
            break
     local properties = {}
        end
      
     end
    -- Must validate some argument early. It is required for future things
     local class_specifics = cfg.class_specifics[tpl_args.class_id]
    for _, k in ipairs(core.default_args) do
     if class_specifics then
        table.insert(g_args._total_args, k)
        for _, k in ipairs(extend_keys) do
         local data = core.map[k]
            if class_specifics[k] then
         if data.func ~= nil then
                for _, v in ipairs(class_specifics[k]) do
             local status, err = pcall(data.func)
                    table.insert(config[k], v)
            -- an error was raised, return the error string instead of the template
                end
            if not status then
            end
                 return err
         end
         if class_specifics['defaults'] then
             for k, v in pairs(class_specifics['defaults']) do
                 config['defaults'][k] = v
             end
             end
         end
         end
     end
     end
      
     return config
     for _, k in ipairs(core.item_classes[g_args.class].args) do
end
         table.insert(g_args._total_args, k)
 
        local data = core.map[k]
function s.process_quest_rewards(tpl_args)
        if data.func ~= nil then
    local rid = 1
             local status, err = pcall(data.func)
     local continue
             -- an error was raised, return the error string instead of the template
    tpl_args.quest_rewards = {}
             if not status then
    tpl_args.vendor_rewards = {}
                 return err
    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
             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
         end
        return
     end
     end
      
     m_item_util = m_item_util or require('Module:Item util')
     -- set defaults
     local qargs = {}
      
    qargs.tables = tpl_args._item_config.tables
     for k, v in pairs(core.item_classes[g_args.class].defaults) do
     qargs.join = {}
         if g_args[k] == nil then
     for _, tbl in ipairs(tpl_args._item_config.tables) do
             g_args[k] = v
         if tbl ~= 'items' then
             qargs.join[#qargs.join+1] = string.format('items._pageID=%s._pageID', tbl)
         end
         end
     end
     end
      
     qargs.join = #qargs.join > 0 and table.concat(qargs.join, ', ') or nil
     -- Mods
     qargs.fields = {
   
        'items._pageName',
    g_args._mods = {}
        'items.name',
    g_args._stats = {}
        'items.metadata_id',
    g_args._subobjects = {}
        'items.class_id',
    for _, k in ipairs({'implicit', 'mod', 'quality'}) do
        'items.rarity_id',
         local success = true
        'items.inventory_icon',
         local i = 1
    }
        while success do
    for _, k in ipairs(tpl_args._base_item_args) do
             success = core.validate_mod{key=k, i=i}
         local arg_def = core.map[k]
            i = i + 1
         if arg_def.field ~= nil then
             qargs.fields[#qargs.fields+1] = string.format('%s.%s', arg_def.table, arg_def.field)
         end
         end
     end
     end
      
     qargs.where = string.format('items.class_id = "%s"', tpl_args.class_id)
     -- Handle extra stats (for gems)
     local result = m_item_util.query_item({
      
        metadata_id = tpl_args.base_item_id,
     if core.class_groups.gems.keys:contains(g_args.class) then
        page = tpl_args.base_item_page,
         m_skill.skill(g_frame, g_args)
        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
     end
   
 
     -- base_item
     tpl_args.base_item = result['items.name']
      
     tpl_args.base_item_page = result['items._pageName']
     core.map.base_item.func()
     tpl_args.base_item_id = result['items.metadata_id']
     table.insert(g_args._total_args, 'base_item')
     h.process_arguments(tpl_args, {'base_item', 'base_item_page', 'base_item_id'})
      
 
     -- Setting semantic properties Part 1 (base values)
     tpl_args.base_item_icon = result['items.inventory_icon']
   
 
    local val
     -- Copy values
   
     for _, k in ipairs(tpl_args._base_item_args) do
     for _, k in ipairs(g_args._total_args) do
         local arg_def = core.map[k]
         local prop = core.map[k].property
        if arg_def.func_fetch ~= nil then
         val = g_args[k]
            arg_def.func_fetch(tpl_args)
        if val == nil then
         elseif arg_def.field ~= nil then
        elseif type(val) == 'table' then
            local value = result[string.format('%s.%s', arg_def.table, arg_def.field)]
            -- unfortunatly, it seems like +sep=; is broken
            if value == nil then
            for _, val in ipairs(g_args[k]) do
                if tpl_args.debug then
                 g_frame:callParserFunction('#set:', {[prop] = val})
                    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
        else
            properties[prop] = val
         end
         end
     end
     end
      
 
     g_frame:callParserFunction('#set:', properties)
     -- Fetch implicit mods from base item
      
     local mods = m_cargo.query(
     -- Subobjects
        {'items' ,'item_mods'},
     for _, properties in ipairs(g_args._subobjects) do
        {'item_mods.id', 'item_mods.is_random', 'item_mods.text'},
         g_frame:callParserFunction('#subobject:', properties)
        {
            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
   
    --
    -- Validate arguments
    --
   
    local x = v.itembox()
   
    mw.logObject(os.clock() - t)
   
    return x
end
end


function p.item_link (frame)
function s.process_mods(tpl_args)
     --
     tpl_args._defined_implicit_mods = {}
     -- Args/Frame
     tpl_args._mods = {}
     --
 
   
     local function parse_mod_arg(tpl_args, type, index)
    g_args = getArgs(frame, {
        local prefix = type .. index
        parentFirst = true,
        local mod_data = {
        removeBlanks = false,
            is_implicit = type == 'implicit',
    })
            is_explicit = type == 'explicit',
    g_frame = util.misc.get_frame(frame)
            is_map_fragment_bonus = type == 'map_fragment_bonus',
   
            is_random = false,
    -- Backwards compability
        }
    g_args.item_name = g_args.item_name or g_args[1]
        local mods_table = mod_data.is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
    g_args.name = g_args.name or g_args[2]
 
   
        -- By mod id
    if util.table.has_all_value(g_args, {'page', 'item_name'}) then
        local value = tpl_args[prefix]
         error('page or item name must be specified')
        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
     end
      
     if #tpl_args._mods > 0 then
    local img
        local mods = {}
    local result
        local mod_ids = {}
   
        local non_random_mod_ids = {}
    if util.table.has_one_value(g_args, core.item_link_params, nil) then
        for _, mod_data in ipairs(tpl_args._mods) do
         local query = {}
            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
          
          
         if g_args.page ~= nil then
         -- fetch stats
             -- TODO returns the result even if the + format is specified.  
        results = m_cargo.query(
             query[#query+1] = string.format('[[%s]]', g_args.page)
            {'mods', 'mod_stats'},
         elseif g_args.item_name ~= nil then
             {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
             query[#query+1] = string.format('[[Has name::%s]] [[Has inventory icon::+]] [[Has infobox HTML::+]]', g_args.item_name)
             {
                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
         end
          
          
         query[#query+1] = '?Has name'
         if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        query[#query+1] = '?Has inventory icon'
            -- fetch sell prices
        query[#query+1] = '?Has infobox HTML'
            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
          
          
         -- attributes
         if missing_sell_price then
        result = util.smw.query(query, g_frame)
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
          
          
         if #result == 0 then
         -- Set sell price on page
            return util.html.error{msg=string.format('No results found.')} .. core.item_link_broken_cat
        for name, amount in pairs(tpl_args.sell_prices) do
        elseif #result > 1 then
            -- sell_price_order is defined in core.map.sell_prices_override
             return util.html.error{msg=string.format('Too many results. Consider using page parameter instead.')} .. core.item_link_broken_cat
            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
         end
          
         table.sort(tpl_args.sell_price_order)
        result = result[1]
    end
     else
end
         result = {g_args.page or g_args.item_name}
 
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
     end
      
      
     for _, k in ipairs(core.item_link_params) do
    -- Handle local item stat math - additions, increases, etc.
         local prop = core.map[k].property
     for key, stat_def in pairs(core.stat_map) do
         if g_args[k] ~= nil then
         local arg = stat_def.arg or key
             result[prop] = g_args[k]
        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
     end
     end
      
 
     if result['Has inventory icon'] ~= '' then
     -- Transpose stats into cargo data
        img = string.format('[[%s]]', result['Has inventory icon'])
     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
    -- output
end
   
 
    local container = mw.html.create('span')
function s.process_weapon_dps(tpl_args)
     container
     for key, dps_def in pairs(core.dps_map) do
         :attr('class', 'inline-infobox-container')
         local damage = {
        :wikitext(img)
            min = {},
        :wikitext(string.format('[[%s|%s]]', result[1], result['Has name'] or result[1]))
            max = {},
          
        }
    if result['Has infobox HTML'] ~= '' then
        for var_type, value in pairs(damage) do
         container
            -- covers the min/max/avg range
             :tag('span')
            for short_key, range_def in pairs(c.range_map) do
                :attr('class', 'inline-infobox-hover')
                value[short_key] = 0
                :wikitext(result['Has infobox HTML'])
                for _, damage_key in ipairs(dps_def.damage_args) do
                :done()
                    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
       
    return tostring(container)
end
end


-- ----------------------------------------------------------------------------
function s.process_gem_variants(tpl_args)
-- Result formatting templates for SMW queries
    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
-- Template:
                -- 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 p.simple_item_list_row(frame)
function s.get_categories(tpl_args)
     -- Args
     local cats = {}
     g_args = getArgs(frame, {
    if tpl_args._flags.is_prophecy then
         parentFirst = true
        table.insert(cats, i18n.categories.prophecies)
     })
    elseif tpl_args._flags.is_blight_item then
     g_frame = util.misc.get_frame(frame)
        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
    local args = util.string.split_args(g_args.userparam, {sep=', '})
         table.insert(cats, i18n.categories.derived_items)
    g_args.userparam = args
   
    local link = p.item_link{page=g_args[1], name=g_args['?Has name'], inventory_icon=g_args['?Has inventory icon'] or '', html=g_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
     else
         error(string.format('Unrecognized format parameter "%s"', args.format))
         table.insert(cats, i18n.categories.base_items)
     end
     end
end


--
    for _, tag in ipairs(tpl_args.acquisition_tags) do
-- Template: SMW item table/skill gem
        if cfg.acquisition_tags[tag] and cfg.acquisition_tags[tag].cat then
--
            table.insert(cats, cfg.acquisition_tags[tag].cat)
 
         end
-- SMW item table/skill_gem/intro
     end
function p.skill_gem_list_intro(frame)
    -- Args
    local tpl_args = getArgs(frame, {
         parentFirst = true
     })
    g_frame = util.misc.get_frame(frame)
      
      
     --
     for _, attr in ipairs(m_game.constants.attribute_order) do
    local args = util.string.split_args(tpl_args.userparam, {sep=', '})
        if tpl_args[attr .. '_percent'] then
     tpl_args.userparam = args
            table.insert(cats, string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class))
        end
     end
      
      
     local tr = mw.html.create('tr')
     if cfg.class_groups.gems.keys[tpl_args.class_id] then
    tr
         for _, tag in ipairs(tpl_args.gem_tags) do
         :tag('th')
            table.insert(cats, string.format(i18n.categories.gem_tag_affix, tag))
            :wikitext('Skill gem')
            :done()
           
    for _, rowinfo in ipairs(core.result.skill_gem) do
        if rowinfo.arg == nil or args[rowinfo.arg] then
            tr
                :tag('th')
                    :wikitext(rowinfo.header)
                    :done()
         end
         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
     end
      
      
     return '<table class="wikitable sortable">' .. tostring(tr)
     if #tpl_args.alternate_art_inventory_icons > 0 then
end
        table.insert(cats, i18n.categories.alternate_artwork)
    end


-- SMW item table/skill gem
     if tpl_args._flags.has_legacy_drop_areas == true then
function p.skill_gem_list_row(frame)
        mw.log('IDs of legacy map areas used in drop_areas:')
    -- Args
        mw.logObject(tpl_args._legacy_drop_areas)
     local tpl_args = getArgs(frame, {
        table.insert(cats, i18n.categories.legacy_drop_areas)
        parentFirst = true
    end
    })
    g_frame = util.misc.get_frame(frame)
      
      
     --
     if tpl_args.release_version == nil then
    local args = util.string.split_args(tpl_args.userparam, {sep=', '})
        table.insert(cats, i18n.categories.missing_release_version)
     tpl_args.userparam = args
     end
      
      
     local tr = mw.html.create('tr')
     if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        table.insert(cats, i18n.categories.improper_modifiers)
    end
      
      
     tr
     for _, k in ipairs({'invalid_recipe_parts', 'duplicate_recipes', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        :tag('td')
         if tpl_args._flags[k] then
            :wikitext(p.item_link{page=tpl_args[1], name=tpl_args['?Has name'], inventory_icon=tpl_args['?Has inventory icon'], html=tpl_args['?Has infobox HTML']})
             table.insert(cats, i18n.categories[k])
            :done()
           
    for _, rowinfo in ipairs(core.result.skill_gem) do
         if rowinfo.arg == nil or args[rowinfo.arg] then
             local value = tpl_args['?' .. rowinfo.property]
            if rowinfo.cast then
                value = rowinfo.cast(value)
            end
            rowinfo.display(tr, value)
         end
         end
     end
     end
      
 
     return tostring(tr)
    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
end


-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------
-- Property views..
-- Main functions
-- ----------------------------------------------------------------------------
-- ----------------------------------------------------------------------------


function v.itembox ()
local function _main(tpl_args)
     --todo: remove g_args.frame ?
    local t = os.clock() -- Start time (for logging)
     local container = v._itembox_core()
    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)
      
      
     for _, k in ipairs({'inventory_icon', 'gem_icon'}) do
     -- Using general purpose function to handle release and removal versions
         if g_args[k] ~= nil then
    m_util.args.version(tpl_args)
             container:wikitext(string.format('[[%s]]', g_args[k]))
 
    -- 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
     end
     end
      
      
     local infobox = tostring(container)
     -- 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)
      
      
     -- Store the infobox so it can be accessed with ease on other pages
     -- Recipes
     g_frame:callParserFunction('#set:', {['Has infobox HTML'] = infobox})
     h.process_recipes(tpl_args)
      
      
     local span = mw.html.create('span')
     -- Quest reward info
     span
    s.process_quest_rewards(tpl_args)
        :attr('class', 'infobox-page-container')
 
        :wikitext(infobox)
     -- Gem variants
       
     if cfg.class_groups.gems.keys[tpl_args.class_id] then
     if g_args.skill_screenshot then
         s.process_gem_variants(tpl_args)
         span:wikitext(string.format('<br>[[%s|300px]]', g_args.skill_screenshot))
     end
     end
      
      
     return tostring(span) .. v._itembox_categories()
     -- ------------------------------------------------------------------------
end
    -- Infobox handling
    -- ------------------------------------------------------------------------
 
    --
    -- Tabs
    --


function v._itembox_core()
     local tabs
     -- needed later for setting caculated properties
     if type(tpl_args._variants) == 'table' and #tpl_args._variants > 1 then   
     g_args._properties = {}
         tabs = mw.html.create('div')
    local frame_css = {
            :addClass('itembox-tabs')
        ['Currency'] = 'currency',
         for _, v in ipairs(tpl_args._variants) do
        ['Microtransactions'] = 'currency',
             local tab = tabs:tag('span')
        ['Active Skill Gems'] = 'gem',
             tab:addClass('itembox-tab')
        ['Support Skill Gems'] = 'gem',
             if v.current then
        ['Quest'] = 'quest',
                 tab:addClass('-selected')
         ['Divination Card'] = 'divicard'
             end
    }
             if v.icon then
    local container = mw.html.create('div')
                 tab:wikitext(string.format('[[%s|34x34px|link=%s|alt=%s]]', v.icon, v.page, v.name))
        :attr( 'class', 'itembox-' .. ( string.lower(g_args.frame or frame_css[g_args.class] or g_args.rarity) .. ' ' .. g_args.class))
   
    if g_args.class == 'Divination Card' then
         --TODO div card code
    else
        container
            :tag('span')
                :attr( 'class', 'itemboxheader-' .. (g_args.base_item and 'double' or 'single') )
             :tag('span')
                :attr('class', 'itemboxheaderleft')
                :done()
             :tag('span')
                :attr('class', 'itemboxheaderright')
                :done()
             :tag('span')
                :attr('class', 'itemboxheadertext')
                :wikitext( g_args.name .. (g_args.base_item and '<br>' .. g_args.base_item or '') )
                 :done()
            :done()
           
        local grpcont
        local valid
        local statcont = container:tag('span')
        statcont
             :attr('class', 'itemboxstats')
            :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 g_args[key] == nil then
                                valid = false
                                break
                            end
                        end
                    elseif type(disp.args) == 'function' then
                        valid = disp.args()
                    end
                    if valid then
                        grpcont[#grpcont+1] = disp.func()
                    end
                end
             else
             else
                 grpcont = group.func()
                 tab:wikitext(m_util.html.wikilink(v.page, v.name))
            end
           
            if #grpcont > 0 then
                statcont
                    :tag('span')
                    :attr('class', 'itemboxstatsgroup ' .. (group.css_class or ''))
                    :wikitext(table.concat(grpcont, '<br>'))
                    :done()
             end
             end
         end
         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)
      
      
     g_frame:callParserFunction('#set:', g_args._properties)
     out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
      
      
     return container
     --
end
    --  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


function v._itembox_categories()
     if query_id then
     cats = {}
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    cats[#cats+1] = g_args.class
    if g_args.rarity == 'Unique' then
        cats[#cats+1] = 'Unique ' .. g_args.class
     end
     end
      
      
     for _, attr in ipairs(m_game.constants.attributes) do
    -- ------------------------------------------------------------------------
         if g_args[attr.long_lower .. '_percent'] then
    -- Store cargo data
            cats[#cats+1] = string.format('%s %s', attr.long_upper, g_args.class)
    -- ------------------------------------------------------------------------
 
    -- 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
     end
     end
      
      
     local suffix
     -- Don't store cargo data in testing mode
     if g_args.class == 'Active Skill Gems' or g_args.class == 'Support Skill Gems' then
     if not tpl_args.test then
         suffix = ' (gem tag)'
         local attach = {}
    end
        for _, data in pairs(tpl_args._store_data) do
    if suffix ~= nil then
            if attach[data._table] == nil then
        for _, tag in ipairs(g_args.gem_tags) do
                local i = 0
            cats[#cats+1] = tag .. suffix
                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
     end
     end
      
      
     -- TODO: add maintenance categories
     -- 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
     -- Output formatting
        mw.log(os.clock() - t)
     --
        mw.log('Start logging tpl_args.')
      
        mw.logObject(tpl_args)
     return util.misc.add_category(cats)
        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
end
-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------
local p = {}
--
-- Template:Item
--
p.main = m_util.misc.invoker_factory(_main, {
    parentFirst = true,
})
p.item = p.main


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"