Path of Exile Wiki

Please consider helping keep the wiki up to date. Check the to-do list of updates needed for version 3.14.0.

Game data exports will becoming later as the technical changes in addition to regular changes take some more time.

READ MORE

Path of Exile Wiki
Register
Advertisement
Template info icon Module documentation[view] [edit] [history] [purge]

The item module provides functionality for various item-related templates.

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,

Item templates

Module:Item2

All templates defined in Module:Item2:

Module:Item table

All templates defined in Module:Item table:

Module:Item link

All templates defined in Module:Item link:

Module:Item acquisition

-- Cargo reworked item module

-- ----------------------------------------------------------------------------
-- TODO
-- ----------------------------------------------------------------------------
-- Items
-- -----
-- Check if abyss jewels actually have radius modifiers
-- 
-- Aggregate ids from skill id from modifiers
-- 
--
-- unique items:
--  3D art
--  supporter attribution
--
-- Maps: 
--  Area level can be retrieved eventually
--
-- Essence: 
--  type column
--  monster modifier info
--
-- random modifier
-- -> sell price must consider random mods
--
-- ----------
-- Item class
-- ----------
--
-- remove the ul if name_list is not provided
-- maybe smw

-- ----------------------------------------------------------------------------
-- Imports
-- ----------------------------------------------------------------------------
local m_util = require('Module:Util/sandbox')
local getArgs = require('Module:Arguments').getArgs
local m_game = require('Module:Game')
local m_skill = require('Module:Skill/sandbox')
local m_area = require('Module:Area')
local m_cargo = require('Module:Cargo')
local f_item_link = require('Module:Item link').item_link

local p = {}
local c = {}
c.image_size = 39
c.image_size_full = c.image_size * 2
c.query_default = 50
c.query_max = 200

c.lang = mw.language.new('en')

-- ----------------------------------------------------------------------------
-- Strings
-- ----------------------------------------------------------------------------
-- This section contains strings used by this module.
-- Add new strings here instead of in-code directly, this will help other
-- people to correct spelling mistakes easier and help with translation to
-- other PoE wikis.
--
-- TODO: Maybe move this out to a separate sub-page module
local i18n = {
    inventory_icon = 'File:%s inventory icon.png',
    status_icon = 'File:%s status icon.png',
    divination_card_art = 'File:%s card art.png',
    gem_tag_category = '[[:Category:%s (gem tag)|%s]]',
    
    misc = {
        -- used to identify betrayal map series to avoid showing area infobox.
        betrayal = 'Betrayal',
        upgraded_from_map = 'Lower tier map upgrades randomly into a directly connected higher tier map.',
    },

    categories = {
        -- maintenance cats
        improper_modifiers = 'Items with improper modifiers',
        missing_release_version = 'Items without a release version',
        broken_upgraded_from_reference = 'Items with broken item references in upgraded from parameters', 
        duplicate_upgraded_from_reference = 'Items with duplicate sets in upgraded from parameters',
        duplicate_query_area_ids = 'Items with duplicate area ids from queries',
        base_items = 'Base items',
        derived_items = 'Derived items',
        sell_prices_override = 'Items with sell prices overrides',

        -- regular cats
        alternate_artwork = 'Items with alternate artwork',

        -- misc
        gem_tag_affix = '%s (gem tag)',
        unique_affix = 'Unique %s',
        
        prophecies = 'Prophecies',
        blight_item = 'Oils',
        talismans = 'Talismans',
        essences = 'Essences',
    },

    stat_skip_patterns = {
        maps = {
            '%d+%% increased Quantity of Items found in this Area',
            '%d+%% increased Rarity of Items found in this Area',
            '%+%d+%% Monster pack size',
            -- ranges
            '%(%d+%-%d+%)%% increased Quantity of Items found in this Area',
            '%(%d+%-%d+%)%% increased Rarity of Items found in this Area',
            '%+%(%d+%-%d+%)%% Monster pack size',
        },
        jewels = {
            'Limited to %d+ %(Hidden%)',
            'Jewel has a radius of %d+ %(Hidden%)',
        },
    },

    help_text_defaults = {
        active_gem = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.',
        support_gem = '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.',
        jewel = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.',
    },
    
    -- texts specific to upgraded from
    upgraded_from_tooltips = {
        -- formatters 
        f = {
            random = 'random %s',
            random_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'corrupted')),
            random_unidentified_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'unidentified corrupted')),
            random_two_implicit_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'two-implicit corrupted')),
            random_item_level_x = 'random item level %s %s',
            random_x_link = 'random %s-link %s',
            random_x_link_item_level_y = 'random %s-link item level %s %s',
            random_x_amount = 'random %s (%sx)',
            random_shaper = 'random shaper %s',
            random_shaper_item_level_x = 'random shaper item level %s %s',
            random_elder_item_level_x = 'random elder item level %s %s',
        
            tier_x_map = 'tier %s map',
            level_x_gem = 'level %s gem',
            level_x_y_gem = 'level %s %s gem',
            superior_gem_q_x = 'superior gem (Q%s)',
            superior_x_gem_q_y = 'superior %s gem (Q%s)',
            
            x_item = '%s item',
        },
        
        -- items / rewards not covered by module game
        agate_amulet = 'Agate Amulet',
        unset_ring = 'Unset Ring',
        gold_ring = 'Gold Ring',
        prismatic_ring = 'Prismatic Ring',
        two_stone_ring = 'Two-Stone Ring',
        talisman = 'Talisman',
        tier_1_talisman = 'tier 1 talisman',
        breachstone = 'Breachstone',
        scarab = 'Scarab',
        gilded_scarab = 'Gilded Scarab',
        divination_card = 'divination card',
        deafening_essence = 'Deafening Essence',
        shrieking_essence = 'Shrieking Essence',
        essence = 'Essence',
        harbinger_fragment = 'Harbinger Fragment',
        body_armour = 'body armour',
        shield = 'Shield',
        map = 'Map',
        belt = 'Belt',
        armour = 'Armour',
        weapon = 'Weapon',
        jewellery = 'Jewellery',
        one_hand_weapon = 'one-handed weapon',
        two_hand_weapon = 'two-handed weapon',
        sword = 'Sword',
        axe = 'Axe',
        flask = 'Flask',
        amulet = 'Amulet', 
        ring = 'Ring',
        league_specific_item = 'league-specific item',
        item = 'item',
        fated_item = 'fated unique item',
        
        -- prefix
        life = 'Life',
        
        --
        -- used within essences
        --
        essence_plus_one_level = string.format('+1 level %s outcome', m_util.html.poe_color('corrupted', 'corruption')),
        essence_type_change = string.format('type change %s outcome', m_util.html.poe_color('corrupted', 'corruption')),
    },

    -- Used by the item info box
    tooltips = {
        corrupted = m_util.html.poe_color('corrupted', 'Corrupted'),
        support_icon = 'Icon: %s',
        radius = 'Radius: %s',
        mana_cost = 'Mana Cost: %s',
        mana_reserved = 'Mana Reserved: %s',
        cost = 'Cost: %s',
        reservation = 'Reservation: %s',
        mana = 'Mana',
        life = 'Life',
        energy_shield = 'Energy Shield',
        rage = 'Rage',
        mana_multiplier = 'Cost and Reservation Multiplier: %s',
        vaal_souls_per_use = 'Souls Per Use: %s',
        stored_uses = 'Can Store %s Use(s)',
        vaal_soul_gain_prevention_time = 'Soul Gain Prevention: %s',
        cooldown_time = 'Cooldown Time: %s',
        cast_time = 'Cast Time: %s',
        critical_strike_chance = 'Critical Strike Chance: %s',
        attack_speed_multiplier = 'Attack Speed: %s',
        attack_speed_multiplier_fmt = '%i%% of Base',
        damage_effectiveness = 'Effectiveness of Added Damage: %s',
        projectile_speed = 'Projectile Speed: %s',
        quality = 'Quality: %s',
        physical_damage = 'Physical Damage: %s',
        elemental_damage = 'Elemental Damage: %s',
        chaos_damage = 'Chaos Damage: %s',
        attacks_per_second = 'Attacks per Second: %s',
        weapon_range = 'Weapon Range: %s',
        map_level = 'Map Level: %s',
        map_tier = 'Map Tier: %s',
        map_guild_character = m_util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': %s',
        item_quantity = 'Item Quantity: %s',
        item_rarity = 'Item Rarity: %s',
        monster_pack_size = 'Monster Pack Size: %s',
        limited_to = 'Limited to: %s',
        flask_mana_recovery = 'Recovers %s Mana over %s seconds',
        flask_life_recovery = 'Recovers %s Life over %s seconds',
        flask_duration = 'Lasts %s Seconds',
        flask_charges_per_use = 'Consumes %s of %s Charges on use',
        chance_to_block = 'Chance to Block: %s',
        armour = 'Armour: %s',
        evasion = 'Evasion: %s',
        energy_shield = 'Energy Shield: %s',
        movement_speed = 'Movement Speed: %s',
        talisman_tier = 'Talisman Tier: %s',
        stack_size = 'Stack Size: %s',
        essence_level = 'Essence Level: %s',
        blight_item_tier = 'Oil Tier: %s',
        requires = 'Requires %s',
        level_inline = 'Level %s',
        level = 'Level: %s',
        gem_quality = 'Per 1% Quality:',
        gem_quality_1 = 'Superior',
        gem_quality_2 = 'Anomalous',
        gem_quality_3 = 'Divergent',
        gem_quality_4 = 'Phantasmal',
        variation_singular = 'Variation',
        variation_plural = 'Variations',
        favour_cost = 'Favour cost: %s',
        seal_cost = 'Seal Cost: <br>%s',
        cannot_be_traded_or_modified = 'Cannot be traded or modified',
        
        -- harvest seeds
        
        seed_tier = 'Seed Tier: %s',
        seed_monster = 'Spawns a level ? Monster when Harvested',
        seed_lifeforce_gained = 'Provides ? Units of Raw %s Lifeforce when Harvested',
        seed_growth_cycles = 'Can be Harvested after %s Growth Cycles',
        
        seed_lifeforce_consumed = 'Consumes (%s%%) %s Units of Condensed Lifeforce per Growth Cycle',
        seed_required_seeds = 'Requires %s Adjacent %s Seeds of at least Tier %s to Grow',
        
        -- harvest plant boosters, not used at the moment
        plant_booster_extra_chances = 'Seeds in radius give the rarest of %s chosen Crafting Options when Harvested',
        plant_booster_lifeforce = 'Seeds in radius produce %s more Lifeforce when Harvested',
        plant_booster_additional_crafting_optioons = 'Seeds in radius have %s chance to generate additional Crafting Options when Harvested',
        
        -- heist
        heist_required_npc = 'This item can be equipped by: %s',
        heist_required_job = 'Requires %s in %s',
        heist_any_job = 'Any job',
        
        -- ClientStrings.dat -> WeaponClassDisplayName.*
        item_class_map = {
            ['Staff'] = 'Staff',
            ['Bow'] = 'Bow',
            ['Wand'] = 'Wand',
            ['Two Hand Axe'] = 'Two Handed Axe',
            ['Two Hand Sword'] = 'Two Hand Sword',
            ['Two Hand Mace'] = 'Two Hand Mace',
            ['Warstaff'] = 'Warstaff',
            ['Sceptre'] = 'Sceptre',
            ['One Hand Mace'] = 'One Handed Mace',
            ['One Hand Axe'] = 'One Handed Axe',
            ['One Hand Sword'] = 'One Handed Sword',
            ['Thrusting One Hand Sword'] = 'One Handed Sword',
            ['Claw'] = 'Claw',
            ['Dagger'] = 'Dagger',
            ['Rune Dagger'] = 'Rune Dagger',
            ['FishingRod'] = 'Fishing Rod',
            ['HideoutDoodad'] = 'Hideout Item',
        },
        
        random_mod = '&lt;&lt;random modifier %s&gt;&gt;',
        
        --
        -- secondary infobox
        --
        extra_info = 'Additional Information',
        header_overall = 'Region Upgrades Chart',
        header_upgrades = 'Upgrade Level',
        header_map_tier = 'Tier',
        header_map_level = 'Map Level',
        header_connections = 'Connections',
        
        drop_restrictions = 'Acquisition',
        league_restriction = m_util.html.abbr('League(s):', 'Item can be obtained in relation to these league(s)') .. ' %s',
        drop_disabled = 'DROP DISABLED',
        
        purchase_costs = m_util.html.abbr('Purchase Costs', 'Cost of purchasing an item of this type at NPC vendors. This does not indicate whether NPCs actually sell the item.'),
        sell_price = m_util.html.abbr('Sell Price', 'Items or currency received when selling this item at NPC vendors. Certain vendor recipes may override this value.'),
        
        damage_per_second = 'Weapon DPS',
        physical_dps = m_game.constants.damage_types.physical.short_upper,
        fire_dps = m_game.constants.damage_types.fire.short_upper,
        cold_dps = m_game.constants.damage_types.cold.short_upper,
        lightning_dps = m_game.constants.damage_types.lightning.short_upper,
        chaos_dps = m_game.constants.damage_types.chaos.short_upper,
        elemental_dps = 'Elemental',
        poison_dps = 'Phys+Chaos',
        dps = 'Total',
        
        misc = 'Miscellaneous',
        item_class = 'Item class: %s',
        metadata_id = 'Metadata ID: %s',
    },

    damage = {
        standard_range = '%s-%s',
        variable_range = '%s&nbsp;to&nbsp;%s',
    },

    item_class_infobox = {
        page = '[[Item class]]',
        info = m_util.html.abbr('(?)', 'Item classes categorize items. Classes are often used to restrict items or skill gems to a specific class or by item filters'),
        also_referred_to_as = 'Also referred to as:',
    },

    debug = {
        base_item_field_not_found = 'Base item property not found: %s.%s',
        field_value_mismatch = 'Value for argument "%s" is set to something else then default: %s',
    },

    errors = {
        missing_base_item = 'Rarity is set to above normal, but base item is not set. A base item for rarities above normal is required!',
        missing_rarity = 'Base item parameter is set, but rarity is set to normal. A rarity above normal is required!',
        missing_amount = 'Item amount is missing or not a number (%s)',
        upgraded_from_broken_reference = 'Item reference in %s is broken (value: %s)',
        upgraded_from_duplicate = 'Automatic upgraded from entry is duplicated on page in upgraded_from_set%s',
        duplicate_base_items = 'More then one result found for the specified base item. Consider using base_item_page or base_item_id to narrow down the results.',
        base_item_not_found = 'Base item could not be found in the database. Check for spelling mistakes or whether the base item page exists on the wiki. If the base item page exists on the wiki, but it can not be found please null-edit the page.',
        invalid_league = '%s is not a recognized league',
        invalid_tag = '%s is not a valid tag',
        generic_argument_parameter = 'Unrecognized %s parameter "%s"',
        generic_required_parameter = 'Parameter "%s" must be specified for this item type.',
        non_unique_flag = 'Only unique items can are egible for the flag "%s".',
        duplicate_area_id_from_query = 'Query found duplicate area ids that do not need to be set on the item. Duplicate ids: "%s"',
        duplicate_metadata = 'Duplicate metadata id "%s" on page "%s"',
        invalid_influence = 'The influence "%s" is invalid. Acceptable values are "shaper", "elder", "crusader", "redeemer", "hunter" and "warlord".',
        invalid_class = 'The item class name "%s" is invalid.',
        invalid_class_id = 'The item class id "%s" is invalid. Using the correct item class id is required for the template to work correctly.',
        invalid_rarity_id = 'The rarity id "%s" is invalid. Acceptable values are "normal", "magic", "rare" and "unique".',
        invalid_region_upgrade_count = 'atlas_connection%s_tier: Invalid amount (%s) of connections, only 5 are allowed',
    },
}

-- ----------------------------------------------------------------------------
-- Other stuff
-- ----------------------------------------------------------------------------

local h = {}

function h.debug(tpl_args, func)
    if tpl_args.debug ==  nil then
        return
    end
    func()
end

function h.na_or_val(tr, value, func)
    if value == nil then
        tr:wikitext(m_util.html.td.na())
    else
        local raw_value = value
        if func ~= nil then
            value = func(value)
        end
        tr
            :tag('td')
                :attr('data-sort-value', raw_value)
                :wikitext(value)
                :done()
    end
end

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

h.range_fields = {
    {
        field = '_range_minimum',
        type = nil,
    },
    {
        field = '_range_maximum',
        type = nil,
    },
    {
        field = '_range_average',
        type = nil,
    },
        {
        field = '_range_text',
        type = 'Text',
    },
    {
        field = '_range_colour',
        type = 'String',
    },
    {
        field = '_html',
        type = 'Text',
    },

}

function h.handle_range_args(tpl_args, frame, argument_key, field, value, fmt_options)
    fmt_options = mw.clone(fmt_options)
    fmt_options.return_color = true
    local html, colour = m_util.html.format_value(tpl_args, frame, value, fmt_options)
    tpl_args[argument_key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = colour
    
    fmt_options = mw.clone(fmt_options)
    fmt_options.no_color = true
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, frame, value, fmt_options)
end

function h.stats_update(tpl_args, id, value, modid, key)
    if tpl_args[key][id] == nil then
        tpl_args[key][id] = {
            references = {modid},
            min = value.min,
            max = value.max,
            avg = value.avg,
        }
    else
        if modid ~= nil then
            table.insert(tpl_args[key][id].references, modid)
        end
        tpl_args[key][id].min = tpl_args[key][id].min + value.min
        tpl_args[key][id].max = tpl_args[key][id].max + value.max
        tpl_args[key][id].avg = tpl_args[key][id].avg + value.avg
    end
end

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

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

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

-- ----------------------------------------------------------------------------
-- core
-- ----------------------------------------------------------------------------

local core = {}

function core.build_cargo_data(tpl_args, frame)
    for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
        -- Need to clone the table here because we'll be changing the table as we run though
        -- TODO: Optimize this?
        for k, _ in pairs(mw.clone(core.cargo[table_name].fields)) do
            field_data = core.cargo[table_name].fields[k]
            field_data.table = table_name
            for _, stat_data in pairs(core.stat_map) do
                if stat_data.field == k then
                    for _, range_field in ipairs(h.range_fields) do
                        local field_name = stat_data.field .. range_field.field
                        
                        local data = {
                            no_copy = true,
                            table = table_name,
                            field = field_name,
                            -- if the type is nil, use the parent type
                            -- this is set integer/float values correctly
                            type = range_field.type or field_data.type,
                        }
                        
                        core.cargo[table_name].fields[field_name] = data
                        core.map[field_name] = data
                    end
                    break
                end
            end
            if table_name == 'weapons' then
                for _, dps_data in ipairs(core.dps_map) do
                    for _, range_field in ipairs(h.range_fields) do
                        local field_name = dps_data.field .. range_field.field
                        
                        local data = {
                            no_copy = true,
                            table = table_name,
                            field = field_name,
                            -- dps values are floating points
                            type = range_field.type or 'Float',
                        }
                    
                        core.cargo[table_name].fields[field_name] = data
                        core.map[field_name] = data
                    end
                end
            end
        end
    end
end

function core.validate_mod(tpl_args, frame, args)
    -- args:
    --  key   - implict or explicit
    --  i
    --  value
    local prefix = args.key .. args.i
    local value = tpl_args[prefix]
    local out = {
        result=nil,
        -- commited to cargo at a later point
        id=nil,
        stat_text=nil,
        is_implicit=(args.key == 'implicit'),
        is_random=nil,
    }
    
    if value ~= nil then
        out.id = value
        out.stat_text = tpl_args[prefix .. '_text']
        out.is_random = false
        table.insert(tpl_args._mods, out)
        
        return true
    elseif tpl_args[prefix .. '_random_list'] then
        tpl_args._flags.random_mods = true
        value = m_util.string.split(tpl_args[prefix ..  '_random_list'], ',%s*')
        for _, mod_id in ipairs(value) do
            table.insert(tpl_args._mods, {
                result = nil,
                id = mod_id,
                stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, args.i),
                is_implicit = (args.key == 'implicit'),
                is_random = true,
            })
        end
        
        return true
    elseif tpl_args[prefix .. '_text'] then
        value = tpl_args[prefix .. '_text']
        tpl_args._flags.text_modifier = true
        out.result = value
        out.stat_text = value
        out.is_random = false
        table.insert(tpl_args._mods, out)
        
        return true
    end
    
    return false
end

function core.process_smw_mods(tpl_args, frame)
    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
                mod_ids[#mod_ids+1] = mod_data.id
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_random = mod_data.is_random,
            }
        end
        
        local results = m_cargo.array_query{
            tables={'mods'},
            fields={'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            id_field='mods.id',
            id_array=mod_ids,
        }
        
        for _, data in ipairs(results) do
            local mod_data = mods[data['mods.id']]
            mod_data.result = data
            
            if mod_data.is_random == false then
                 -- update item level requirement
                local keys = {'required_level_final'}
                -- only update base item requirement if this is an implicit
                if mod_data.key == 'implicit' then
                    keys[#keys+1] = 'required_level'
                end
                
                for _, key in ipairs(keys) do
                    local req = math.floor(tonumber(data['mods.required_level']) * 0.8)
                    if req > tpl_args[key] then
                        tpl_args[key] = 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('mod_stats.id IS NOT NULL AND mods.id IN ("%s")', table.concat(mod_ids, '", "')),
            }
        )
        for _, data in ipairs(results) do
            -- Stat subobject
            local mod_data = mods[data['mods.id']]
            if mod_data.result.stats == nil then
                mod_data.result.stats = {data, }
            else
                mod_data.result.stats[#mod_data.result.stats+1] = data
            end
        
            local id = data['mod_stats.id']
            local value = {
                min = tonumber(data['mod_stats.min']),
                max = tonumber(data['mod_stats.max']),
            }
            value.avg = (value.min+value.max)/2
            
            local prefix = ''
            if mod_data.is_random then
                prefix = '_random'
            end
            h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats')
            if mod_data.is_implicit then
                h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats')
            else
                h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats')
            end
        end
        
        if 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 tpl_args.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._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['Scroll Fragment'] = 1
        end
        
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in tpl_args.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end

function core.process_base_item(tpl_args, frame, args)
    local where
    if tpl_args.base_item_id ~= nil then
        where = string.format('items.metadata_id="%s"', tpl_args.base_item_id)
    elseif tpl_args.base_item_page ~= nil then
        where = string.format('items._pageName="%s"' , tpl_args.base_item_page)
    elseif tpl_args.base_item ~= nil then
        where = string.format('items.name="%s"' , tpl_args.base_item)
    elseif tpl_args.rarity_id ~= 'normal' then
        error(m_util.html.error{msg=i18n.errors.missing_base_item})
    else
        return
    end
    
    if where ~= nil and tpl_args.rarity_id == 'normal' and not tpl_args._flags.is_prophecy then
        error(m_util.html.error{msg=i18n.errors.missing_rarity})
    end
    
    where = string.format('%s AND items.class_id="%s" AND items.rarity_id="normal"', where, tpl_args.class_id)
    
    local join = {}
    
    for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
        if table_name ~= 'items' then
            join[#join+1] = string.format('items._pageID=%s._pageID', table_name)
        end
    end
    
    local fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
    }
    
    for _, k in ipairs(tpl_args._base_item_args) do
        local data = core.map[k]
        if data.field ~= nil then
            fields[#fields+1] = string.format('%s.%s', data.table, data.field)
        end
    end
    
    local result = m_cargo.query(
        core.item_classes[tpl_args.class_id].tables,
        fields,
        {
            where=where,
            join=table.concat(join, ','),
            groupBy='items._pageID',
        }
    )
    
    if #result > 1 then
        error(m_util.html.error{msg=i18n.errors.duplicate_base_items})
        -- TODO be more explicit in the error?
    elseif #result == 0 then
        error(m_util.html.error{msg=i18n.errors.base_item_not_found})
    end
    
    result = result[1]
    
    tpl_args.base_item_data = result
    core.process_arguments(tpl_args, frame, {array={'base_item', 'base_item_page', 'base_item_id'}})

    --Copy values..
    for _, k in ipairs(tpl_args._base_item_args) do
        local data = core.map[k]
        if data.field ~= nil and data.func_fetch == nil then
            local value = result[string.format('%s.%s', data.table, data.field)]
            -- I can just use data.default since it will be nil if not provided (nil == nil). Neat! ;)
            if value ~= nil and (tpl_args[k] == data.default or type(data.default) == 'function') then
                tpl_args[k] = value
                if data.func ~= nil then
                    data.func(tpl_args, frame)
                end
                if data.func_copy ~= nil then
                    data.func_copy(tpl_args, frame)
                end
            elseif value == nil and not data.debug_ignore_nil then
                h.debug(tpl_args, function ()
                    error(string.format(i18n.debug.base_item_field_not_found, data.table, data.field))
                end)
            elseif tpl_args[k] ~= data.default then
                h.debug(tpl_args, function ()
                    error(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end)
            end
        elseif data.func_fetch ~= nil then
            data.func_fetch(tpl_args, frame)
        end
    end
end

function core.process_arguments(tpl_args, frame, args)
    for _, k in ipairs(args.array) do
        local data = core.map[k]
        if data == nil then
            error(string.format('Invalid key or missing data for "%s"', k))
        end
        if data.no_copy == nil then
            table.insert(tpl_args._base_item_args, k)
        end
        if data.func ~= nil then
            data.func(tpl_args, frame)
            --[[local status, err = pcall(data.func)
            -- an error was raised, return the error string instead of the template
            if not status then
                return err
            end
            ]]--
        end
        if tpl_args[k] == nil then
            if tpl_args.class_id and core.item_classes[tpl_args.class_id].defaults ~= nil and core.item_classes[tpl_args.class_id].defaults[k] ~= nil then
                tpl_args[k] = core.item_classes[tpl_args.class_id].defaults[k]
            elseif data.default ~= nil then
                if type(data.default) == 'function' then
                    tpl_args[k] = data.default(tpl_args, frame)
                else
                    tpl_args[k] = data.default
                end
            end
        end
    end
end
        
function core.process_mod_stats(tpl_args, args)
    local lines = {}
    
    local skip = core.class_specifics[tpl_args.class_id]
    if skip then
        skip = skip.skip_stat_lines
    end 
    
    local random_mods = {}
    
    for _, modinfo in ipairs(tpl_args._mods) do
        if modinfo.is_implicit == args.is_implicit then
            if modinfo.is_random == true then
                if random_mods[modinfo.stat_text] then
                    table.insert(random_mods[modinfo.stat_text], modinfo)
                else
                    random_mods[modinfo.stat_text] = {modinfo}
                end
            else
                if modinfo.id == nil then
                    table.insert(lines, modinfo.result)
                -- Allows the override of the SMW fetched mod texts for this modifier via <modtype><id>_text parameter
                elseif modinfo.text ~= nil then
                     table.insert(lines, modinfo.text)
                else
                    for _, line in ipairs(m_util.string.split(modinfo.result['mods.stat_text'] or '', '<br>')) do
                        if line ~= '' then
                            if skip == nil then
                                table.insert(lines, line)
                            else
                                local skipped = false
                                for _, pattern in ipairs(skip) do
                                    if string.match(line, pattern) then
                                        skipped = true
                                        break
                                    end
                                end
                                if not skipped then
                                    table.insert(lines, line)
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    
    for stat_text, modinfo_list in pairs(random_mods) do
        local text = {}
        for _, modinfo in ipairs(modinfo_list) do
            table.insert(text, modinfo.result['mods.stat_text'])
        end
    
        local tbl = mw.html.create('table')
        tbl
            :attr('class', 'random-modifier-stats mw-collapsed')
            :attr('style', 'text-align: left')
            :tag('tr')
                :tag('th')
                    :attr('class', 'mw-customtoggle-31')
                    :wikitext(stat_text)
                    :done()
                :done()
            :tag('tr')
                :attr('class', 'mw-collapsible mw-collapsed')
                :attr('id', 'mw-customcollapsible-31')
                :tag('td')
                    :wikitext(table.concat(text, '<hr style="width: 20%">'))
                    :done()
                :done()
        table.insert(lines, tostring(tbl))
    end
    
    if #lines == 0 then
        return
    else
        return table.concat(lines, '<br>')
    end
end

function core.process_quest_rewards(tpl_args, frame)
    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(frame, rdata)
            
            -- TODO: Verify quests and quest ids?
        end
        
        rid = rid + 1
    until continue == false
end


function core.process_upgraded_from(tpl_args, frame)
    local query_data = {
        id = {},
        name = {},
        page = {},
    }
    local sets = {}
    
    -- ------------------------------------------------------------------------
    -- Manual data
    -- ------------------------------------------------------------------------
    local setid = #sets + 1
    local set
    repeat
        local prefix = string.format('upgraded_from_set%s_', setid)
        local groupid = 1
        local group
        set = {
            groups = {},
            text = m_util.cast.text(tpl_args[prefix .. 'text']),
            automatic = false,
        }
        repeat 
            local group_prefix = string.format('%sgroup%s_', prefix, groupid)
            group = {
                item_name = tpl_args[group_prefix .. 'item_name'],
                item_id = tpl_args[group_prefix .. 'item_id'], 
                item_page = tpl_args[group_prefix .. 'item_page'], 
                amount = tonumber(tpl_args[group_prefix .. 'amount']),
                notes = m_util.cast.text(tpl_args[group_prefix .. 'notes']),
            }
            
            if group.item_name ~= nil or group.item_id ~= nil or group.item_page ~= nil then
                if group.amount == nil then
                    error(string.format(i18n.errors.missing_amount, group_prefix .. 'amount'))
                else
                    for key, array in pairs(query_data) do
                        local value = group['item_' .. key]
                        if value then
                            if array[value] then
                                table.insert(array[value], {setid, groupid})
                            else
                                array[value] = {{setid, groupid}, }
                            end
                        end
                    end
                    set.groups[#set.groups+1] = group
                end
            end
            
            groupid = groupid + 1
        until group.item_name == nil and group.item_id == nil and group.item_page == nil
        
        -- set was empty, can terminate safely
        if #set.groups == 0 then
            set = nil
        else
            setid = setid + 1
            sets[#sets+1] = set
        end
    until set == nil
    -- ------------------------------------------------------------------------
    -- Automatic
    -- ------------------------------------------------------------------------
    
    --
    --  maps
    --
    local automatic_index = #sets + 1
    -- TODO: 3.9.0 Unsure how this works yet, so disabled for now
    --[[if tpl_args.atlas_connections and tpl_args.rarity_id == "normal" then
        local results = m_cargo.query(
            {'items', 'maps'},
            {'items._pageName',  'items.name'},
            {
                join='items._pageID=maps._pageID',
                where=string.format('items.class_id = "Map" AND items.rarity_id = "normal" AND maps.tier < %s AND items._pageName IN ("%s")', tpl_args.map_tier, table.concat(tpl_args.atlas_connections, '", "')),
            }
        )
        for _, row in ipairs(results) do
            sets[#sets+1] = {
                text = i18n.misc.upgraded_from_map,
                groups = {
                    {
                        item_name = row['items.name'],
                        item_page = row['items._pageName'],
                        amount = 3,
                        notes = nil,
                    },
                },
                automatic = true,
            }
        end
    end]]
    
    --
    -- oils
    --
    if tpl_args._flags.is_blight_item and tpl_args.blight_item_tier > 1 then
        local results = m_cargo.query(
            {'items', 'blight_items'},
            {'items._pageName',  'items.name'},
            {
                join='items._pageID=blight_items._pageID',
                where=string.format('blight_items.tier = %s', tpl_args.blight_item_tier - 1),
            }
        )
        for _, row in ipairs(results) do
            sets[#sets+1] = {
                text = nil,
                groups = {
                    {
                        item_name = row['items.name'],
                        item_page = row['items._pageName'],
                        amount = 3,
                        notes = nil,
                    },
                },
                automatic = true,
            }
        end
    end
    
    
    --
    -- essences
    --
    
    -- exclude remnant of corruption via type
    if tpl_args.is_essence and tpl_args.essence_type > 0 then 
        local results = m_cargo.query(
            {'items', 'essences'},
            {
                'items._pageName',  
                'items.name', 
                'items.metadata_id',
                'essences.category',
                'essences.type',
            },
            {
                join='items._pageID=essences._pageID',
                where=string.format([[
                        (essences.category="%s" AND essences.level = %s)
                        OR (essences.type = %s AND essences.level = %s)
                        OR items.metadata_id = 'Metadata/Items/Currency/CurrencyCorruptMonolith'
                        OR (%s = 6 AND essences.type = 5 AND essences.level >= 5) 
                    ]], 
                    tpl_args.essence_category, tpl_args.essence_level - 1, 
                    tpl_args.essence_type - 1, tpl_args.essence_level,
                    -- special case for corruption only essences
                    tpl_args.essence_type
                ),
                orderBy='essences.level ASC, essences.type ASC',
            }
        )
        
        local remnant = results[1]
        if remnant['items.metadata_id'] ~= 'Metadata/Items/Currency/CurrencyCorruptMonolith' then
            error(string.format('Something went seriously wrong here. Got results: %s', mw.dumpObject(results)))
        end
        for i=2, #results do
            local row = results[i]
            if row['essences.category'] == tpl_args.essence_category then
                -- 3 to 1 recipe
                sets[#sets+1] = {
                    automatic = true,
                    text = nil,
                    groups = {
                        {
                            item_id = row['items.metadata_id'],
                            item_page = row['items._pageName'],
                            item_name = row['items.name'],
                            amount = 3,
                        },
                    },
                }
                -- corruption +1
                sets[#sets+1] = {
                    automatic = true,
                    text = i18n.upgraded_from_tooltips.essence_plus_one_level,
                    groups = {
                        {
                            item_id = row['items.metadata_id'],
                            item_page = row['items._pageName'],
                            item_name = row['items.name'],
                            amount = 1,
                        },
                        {
                            item_id = remnant['items.metadata_id'],
                            item_page = remnant['items._pageName'],
                            item_name = remnant['items.name'],
                            amount = 1,
                        },
                    },
                }
            elseif tonumber(row['essences.type']) == tpl_args.essence_type - 1 then
                -- corruption type change
                sets[#sets+1] = {
                    automatic = true,
                    text = i18n.upgraded_from_tooltips.essence_type_change,
                    groups = {
                        {
                            item_id = row['items.metadata_id'],
                            item_page = row['items._pageName'],
                            item_name = row['items.name'],
                            amount = 1,
                        },
                        {
                            item_id = remnant['items.metadata_id'],
                            item_page = remnant['items._pageName'],
                            item_name = remnant['items.name'],
                            amount = 1,
                        },
                    },
                }
            end
        end
    end
    
    -- data based on mapping
    if tpl_args.drop_enabled and not tpl_args.upgraded_from_disabled then
        for _, data in ipairs(core.automatic_upgraded_from) do
            data.defaults = data.defaults or {}
            local continue = true
            for key, value in pairs(core.automatic_upgraded_from_defaults) do
                local func
                local v = data.defaults[key]
                if v == false then
                    -- check is disabled specifically, continue
                elseif v == nil then
                    func = value
                elseif type(v) == 'function' then
                    func = v
                else 
                    error(string.format('Invalid value for defaults at data %s', mw.dumpObject(data)))
                end
                if func then
                    continue = func(tpl_args, frame) and continue
                    if not continue then
                        break
                    end 
                end
            end
            for _, condition in ipairs(data.condition) do
                continue = condition(tpl_args, frame) and continue
                if not continue then
                    break
                end
            end
            
            if continue then
                sets[#sets+1] = {
                    automatic = true,
                    text = data.text(tpl_args, frame),
                    groups = data.groups,
                }
                for groupid, row in ipairs(data.groups) do
                    if query_data['id'][row.item_id] then
                        table.insert(query_data['id'][row.item_id], {#sets, groupid})
                    else
                        query_data['id'][row.item_id] = {{#sets, groupid}, }
                    end
                end
            end
        end
    end
    
    if #sets == 0 then
        return
    end
    --
    -- Fetch item data in a single query to sacrifice database load with a lot of upgraded_from references
    --
    local query_data_array = {
        id = {},
        name = {},
        page = {},
    }
    local query_fields = {
        id = 'items.metadata_id',
        page = 'items._pageName',
        name = 'items.name',
    }
    local where = {}
    local expected_count = 0
    for key, thing_array in pairs(query_data) do
        for thing, _ in pairs(thing_array) do
            table.insert(query_data_array[key], thing)
        end
        if #query_data_array[key] > 0 then
            expected_count = expected_count + #query_data_array[key]
            local q_data = table.concat(query_data_array[key], '", "')
            table.insert(where, string.format('%s IN ("%s")', query_fields[key], q_data))
        end
    end
    local results = m_cargo.query(
        {'items'},
        {'items._pageName',  'items.name', 'items.metadata_id'},
        {
            where=table.concat(where, ' OR '),
        }
    )
    
    for _, row in ipairs(results) do
        for key, thing_array in pairs(query_data) do
            local set_groups = thing_array[row[query_fields[key]]]
            if set_groups then
                for _, set_group in ipairs(set_groups) do
                    local entry = sets[set_group[1]].groups[set_group[2]]
                    for entry_key, data_key in pairs(query_fields) do
                        -- metadata_id may be nil, since we don't know them for unique items
                        if row[data_key] then
                            entry['item_' .. entry_key] = row[data_key]
                        end
                    end
                end
                -- set this to nil for error checking in later step
                thing_array[row[query_fields[key]]] = nil
            end
        end
    end
    
    -- sbow the broken references if needed
    if #results ~= expected_count then
        -- query data was pruned of existing keys earlier, so only broken keys remain
        for key, array in pairs(query_data) do
            for thing, set_groups in pairs(array) do
                for _, set_group in ipairs(set_groups) do
                    tpl_args._flags.broken_upgraded_from_reference = true
                    tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.upgraded_from_broken_reference, string.format('upgraded_from_set%s_group%s_item_%s', set_group[1], set_group[2], key), thing)
                end
            end
        end
    end
    
    --
    -- Check for duplicates
    --
    local delete_sets = {}
    for i=automatic_index, #sets do
        for j=1, automatic_index-1 do
            if #sets[i].groups == #sets[j].groups then
                local match = true
                for row_id, row in ipairs(sets[i].groups) do
                    -- Only the fields from the database query are matched since we can be sure they're correct. Other fields may be subject to user error.
                    for _, key in ipairs({'item_id', 'item_name', 'item_page'})  do
                        match = match and (row[key] == sets[j].groups[row_id][key])
                    end
                end
                if match then
                    tpl_args._flags.duplicate_upgraded_from_reference = true
                    tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.upgraded_from_duplicate, j)
                    delete_sets[#delete_sets+1] = j 
                end
            end
        end
    end
    
    for offset, index in ipairs(delete_sets) do
        table.remove(sets, index-(offset-1))
    end
    --
    -- Set data
    -- 
    tpl_args.upgrade_from_sets = sets
    
    -- set upgraded_from data
    for i, set in ipairs(sets) do
        tpl_args._subobjects[#tpl_args._subobjects+1] = {
            _table = 'upgraded_from_sets',
            set_id = i,
            text = set.text,
            automatic = set.automatic,
        }
        
        for j, group in ipairs(set.groups) do
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'upgraded_from_groups',
                group_id = j,
                set_id = i,
                item_name = group.item_name,
                item_id = group.item_id,
                item_page = group.item_page,
                amount = group.amount,
                notes = group.notes,
            }
        end
    end
end

--
-- function factory
--
core.factory = {}

function core.factory.cast_text(k, args)
    args = args or {}
    return function (tpl_args, frame)
        tpl_args[args.key_out or k] = m_util.cast.text(tpl_args[k])
    end
end

function core.factory.args_present(...)
    local args = {...}
    return function (tpl_args)
        for _, k in ipairs(args) do
            if tpl_args[k] == nil then
                return false
            end
        end
        return true
    end
end

function core.factory.infobox_line(args)
    -- args:
    --  type: Type of the keys (nil = regular, gem = skill gems, stat = stats)
    --  parts:
    --   [n]:
    --    key: key to use
    --    allow_zero: allow zero values
    --    hide_default: hide the value if this is set
    --    hide_default_key: key to use if it isn't equal to the key parameter
    --    truncate: set to true to truncate the line
    --    -- from m_util.html.format_value --
    --    func: Function to transform the value retrieved from the database
    --    fmt: Format string (or function that returns format string) to use for the value. Default: '%s'
    --    fmt_range: Format string to use for the value range. Default: '(%s-%s)'
    --    color: poe_color code to use for the value range. False for no color. Default: 'mod'
    --    class: Additional css class added to color tag
    --    inline: Format string to use for the output
    --    inline_color: poe_color code to use for the output. False for no color. Default: 'default'
    --    inline_class: Additional css class added to inline color tag
    --  sep: If specified, parts are joined with this separator before being formatted for output
    --  fmt: Format string to use for output. If not specified, parts are simply concatenated
    --  color: poe_color code to use for output. Default: no color
    --  class: Additional css class added to output

    args.parts = args.parts or {}
    return function (tpl_args, frame)
        local base_values = {}
        local temp_values = {}
        if args.type == 'gem' then
            if not core.class_groups.gems.keys[tpl_args.class_id] then
                return
            end
            for i, data in ipairs(args.parts) do
                local value = tpl_args.skill_levels[0][data.key]
                if value ~= nil then
                    base_values[#base_values+1] = value
                    temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
                else
                    value = {
                        min=tpl_args.skill_levels[1][data.key],
                        max=tpl_args.skill_levels[tpl_args.max_level][data.key], 
                    }
                    if value.min == nil or value.max == nil then
                    else
                        base_values[#base_values+1] = value.min
                        temp_values[#temp_values+1] = {value=value, index=i}
                    end
                end
            end
        elseif args.type == 'stat' then
            for i, data in ipairs(args.parts) do
                local value = tpl_args._stats[data.key]
                if value ~= nil then
                    base_values[i] = value.min
                    temp_values[#temp_values+1] = {value=value, index=i}
                end
            end
        else
            for i, data in ipairs(args.parts) do
                base_values[i] = tpl_args[data.key]
                local value = {}
                if tpl_args[data.key .. '_range_minimum'] ~= nil then
                    value.min = tpl_args[data.key .. '_range_minimum']
                    value.max = tpl_args[data.key .. '_range_maximum']
                elseif tpl_args[data.key] ~= nil then
                    value.min = tpl_args[data.key]
                    value.max = tpl_args[data.key]
                end
                if value.min == nil then
                else
                    temp_values[#temp_values+1] = {value=value, index=i}
                end
            end
        end
        
        local final_values = {}
        for i, data in ipairs(temp_values) do
            local opt = args.parts[data.index]
            local insert = false
            if opt.hide_default == nil then
                insert = true
            elseif opt.hide_default_key == nil then
                local v = data.value
                if opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                    insert = true
                end
            else
                local v = {
                    min = tpl_args[opt.hide_default_key .. '_range_minimum'],
                    max = tpl_args[opt.hide_default_key .. '_range_maximum'],
                }
                if v.min == nil or v.max == nil then
                    if opt.hide_default ~= tpl_args[opt.hide_default_key] then
                        insert = true
                    end
                elseif opt.hide_default ~= v.min and opt.hide_default ~= v.max then
                    insert = true
                end
            end
            
            if insert == true then
                table.insert(final_values, data)
            end
        end
        
        -- all zeros = dont display and return early
        if #final_values == 0 then
            return nil
        end
        
        local parts = {}
        for i, data in ipairs(final_values) do
            local value = data.value
            value.base = base_values[data.index]
            
            local options = args.parts[data.index]
            
            if options.color == nil and args.type == 'gem' then
                value.color = 'value'
            end
            if options.truncate then
                options.inline_class = (options.inline_class or '') .. ' u-truncate-line'
            end
            
            parts[#parts+1] = m_util.html.format_value(tpl_args, frame, value, options)
        end
        if args.sep then
            -- Join parts with separator before formatting
            parts = {table.concat(parts, args.sep)}
        end

        -- Build output string
        local out
        if args.fmt then
            out = string.format(args.fmt, unpack(parts))
        else
            out = table.concat(parts)
        end
        if args.color then
            out = m_util.html.poe_color(args.color, out, args.class)
        elseif args.class then
            out = tostring(mw.html.create('em')
                :attr('class', class)
                :wikitext(out)
            )
        end
        return out
    end
end

function core.factory.display_raw_value(key)
    return function(tpl_args, frame)
        return tpl_args[key]
    end
end

function core.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, frame, 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

function core.factory.damage_html(args)
    return function(tpl_args, frame)
        local keys = {
            min = args.key .. '_damage_min',
            max = args.key .. '_damage_max',
        }
        local value = {}
        for ktype, key in pairs(keys) do
            value[ktype] = core.factory.infobox_line{
                parts = {
                    {
                        key = key,
                        color = false,
                        hide_default = 0,
                    }
                }
            }(tpl_args, frame)
        end
        if value.min and value.max then
            local color = args.key or false
            local range_fmt
            if tpl_args[keys.min .. '_range_minimum'] ~= tpl_args[keys.min .. '_range_maximum'] or tpl_args[keys.max .. '_range_minimum'] ~= tpl_args[keys.max .. '_range_maximum'] then
                -- Variable damage range, based on modifier rolls
                if args.key == 'physical' then
                    color = 'mod'
                end
                range_fmt = i18n.damage.variable_range
            else
                -- Standard damage range
                if args.key == 'physical' then
                    color = 'value'
                end
                range_fmt = i18n.damage.standard_range
            end
            value = string.format(range_fmt, value.min, value.max)
            if color then
                value = m_util.html.poe_color(color, value)
            end
            tpl_args[args.key .. '_damage_html'] = value
        end
    end
end

--
-- Display
--
core.display = {}

function core.display.make_main_container(tpl_args, frame, container_type)
    local container = mw.html.create('span')
        :attr('class', 'item-box -' .. tpl_args.frame_type)
    
    if tpl_args.class_id == 'DivinationCard' then
        container
            :tag('span')
                :attr('class', 'divicard-wrapper')
                :tag('span')
                    :attr('class', 'divicard-art')
                    :wikitext( '[[' .. tpl_args.card_art .. '|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-frame')
                    :wikitext( '[[File:Divination card frame.png|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-header')
                    :wikitext(tpl_args.name)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-stack')
                    :wikitext(tpl_args.stack_size)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-reward')
                    :tag('span')
                        :wikitext(tpl_args.description)
                        :done()
                    :done()
                :tag('span')
                    :attr('class', 'divicard-flavour text-color -flavour')
                    :tag('span')
                        :wikitext(tpl_args.flavour_text)
                        :done()
                    :done()
                :done()
        --TODO Extras?
    else
        local header_css
        if tpl_args.base_item and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
        else
            line_type = 'single'
        end
        
        local name_line = tpl_args.name
        if tpl_args.base_item and not tpl_args._flags.is_prophecy then
            name_line = name_line .. '<br>' .. tpl_args.base_item
        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_veiled then
            symbols = {'veiled', 'veiled'}
        end
        
        container
            :tag('span')
                :attr( 'class', 'header -' .. line_type )
                :tag('span')
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[1] or '') )
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[2] or '') )
                    :done()
            :done()
            
        core.display.add_to_container_from_map(tpl_args, frame, container, core.item_display_groups, container_type)
    end
    
    if tpl_args.skill_icon ~= nil then
        container:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
    end
    
    return container
end

function core.display.add_to_container_from_map(tpl_args, frame, container, mapping, container_type)
    local statcont = mw.html.create('span')
    statcont
        :attr('class', 'item-stats')
        :done()
    local count = 0 -- Number of groups in container
    for _, group in ipairs(mapping) do
        local lines = {}
        if group.func == nil then
            for _, line in ipairs(group) do
                local show = true
                if container_type == 'inline' and line.inline == false then -- TODO: This is not used currently. Need to address what is hidden in inline view.
                    show = false
                elseif line.show == false then
                    show = false
                elseif type(line.show) == 'function' then
                    show = line.show(tpl_args, frame, container_type)
                end
                if show then
                    lines[#lines+1] = line.func(tpl_args, frame, container_type)
                end
            end
        else
            lines = group.func(tpl_args, frame, container_type)
        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')
                :attr('class', 'group ' .. (group.class or ''))
                :wikitext(heading .. table.concat(lines, '<br>'))
                :done()
        end
    end

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

function core.display.strip_random_stats(tpl_args, frame, stat_text, container_type)
    if tpl_args._flags.random_mods and container_type == 'inline' 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

--
-- argument mapping
--
-- format:
-- tpl_args key = {
--   no_copy = true or nil           -- When loading an base item, dont copy this key 
--   property = 'prop',              -- Property associated with this key
--   property_func = function or nil -- Function to unpack the property into a native lua value. 
--                                      If not specified, func is used. 
--                                      If neither is specified, value is copied as string
--   func = function or nil          -- Function to unpack the argument into a native lua value and validate it. 
--                                      If not specified, value will not be set.
--   default = object                -- Default value if the parameter is nil
-- }
core.map = {
    -- special params
    html = {
        no_copy = true,
        field = 'html',
        type = 'Text',
        func = nil,
    },
    html_extra = {
        no_copy = true,
        field = 'html_extra',
        type = 'Text',
        func = nil,
    },
    implicit_stat_text = {
        field = 'implicit_stat_text',
        type = 'Text',
        func = function(tpl_args, frame)
            tpl_args.implicit_stat_text = core.process_mod_stats(tpl_args, {is_implicit=true})
        end,
    },
    explicit_stat_text = {
        field = 'explicit_stat_text',
        type = 'Text',
        func = function(tpl_args, frame)
            tpl_args.explicit_stat_text = core.process_mod_stats(tpl_args, {is_implicit=false})
            
            if tpl_args.is_talisman or tpl_args.is_corrupted then
                if tpl_args.explicit_stat_text == nil or tpl_args.explicit_stat_text == '' then
                    tpl_args.explicit_stat_text = i18n.tooltips.corrupted
                else
                    tpl_args.explicit_stat_text = (tpl_args.explicit_stat_text or '') .. '<br>' .. i18n.tooltips.corrupted
                end
            end
        end,
    },
    stat_text = {
        field = 'stat_text',
        type = 'Text',
        func = function(tpl_args, frame)
            local sep = ''
            if tpl_args.implicit_stat_text and tpl_args.explicit_stat_text then
                sep = string.format('<span class="item-stat-separator -%s"></span>', tpl_args.frame_type)
            end
            local text = (tpl_args.implicit_stat_text or '') .. sep .. (tpl_args.explicit_stat_text or '')
            
            if string.len(text) > 0 then
                tpl_args.stat_text = text
            end
        end,
    },
    class = {
        no_copy = true,
        field = 'class',
        type = 'String',
        func = function (tpl_args, frame)
            tpl_args.class = m_game.constants.item.classes[tpl_args.class_id]['long_upper']
            -- Avoids errors with empty item class names later on
            if tpl_args.class == '' then
                tpl_args.class = nil
            end
        end,
    },
    -- processed in core.build_item_classes
    class_id = {
        no_copy = true,
        field = 'class_id',
        type = 'String',
        func = function (tpl_args, frame)
            if m_game.constants.item.classes[tpl_args.class_id] == nil then
                error(string.format(i18n.errors.invalid_class_id, tostring(tpl_args.class_id)))
            end
        end
    },
    -- generic
    rarity_id = {
        no_copy = true,
        field = 'rarity_id',
        type = 'String',
        func = function (tpl_args, frame)
            if m_game.constants.rarities[tpl_args.rarity_id] == nil then
                error(string.format(i18n.errors.invalid_rarity_id, tostring(tpl_args.rarity_id)))
            end
        end
    },
    rarity = {
        no_copy = true,
        field = 'rarity',
        type = 'String',
        func = function(tpl_args, frame)
            tpl_args.rarity = m_game.constants.rarities[tpl_args.rarity_id]['long_upper']
        end
    },
    name = {
        no_copy = true,
        field = 'name',
        type = 'String',
        func = nil,
    },
    size_x = {
        field = 'size_x',
        type = 'Integer',
        func = m_util.cast.factory.number('size_x'),
    },
    size_y = {
        field = 'size_y',
        type = 'Integer',
        func = m_util.cast.factory.number('size_y'),
    },
    drop_rarities_ids = {
        no_copy = true,
        field = 'drop_rarity_ids',
        type = 'List (,) of Text',
        func = function(tpl_args, frame)
            tpl_args.drop_rarities_ids = nil
            if true then return end
            -- Drop rarities only matter for base items.
            if tpl_args.rarity_id ~= 'normal' then
                return
            end
            
            if tpl_args.drop_rarities_ids == nil then
                tpl_args.drop_rarities_ids = {}
                return
            end
                
            tpl_args.drop_rarities_ids = m_util.string.split(tpl_args.drop_rarities_ids, ',%s*')
            for _, rarity_id in ipairs(tpl_args.drop_rarities_ids) do
                if m_game.constants.rarities[rarity_id] == nil then
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rarity_id)))
                end
            end
        end,
    },
    drop_rarities = {
        no_copy = true,
        field = nil,
        type = 'List (,) of Text',
        func = function(tpl_args, frame)
            tpl_args.drop_rarities = nil
            if true then return end
            -- Drop rarities only matter for base items.
            if tpl_args.rarity_id ~= 'normal' then
                return
            end
            
            local rarities = {}
            for _, rarity_id in ipairs(tpl_args.drop_rarities_ids) do
                rarities[#rarities+1] = m_game.constants.rarities[rarity_id].full
            end
            tpl_args.drop_rarities = rarities
        end,
    },
    drop_enabled = {
        no_copy = true,
        field = 'drop_enabled',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('drop_enabled'),
        default = true,
    },
    drop_level = {
        no_copy = true,
        field = 'drop_level',
        type = 'Integer',
        func = m_util.cast.factory.number('drop_level'),
    },
    drop_level_maximum = {
        no_copy = true,
        field = 'drop_level_maximum',
        type = 'Integer',
        func = m_util.cast.factory.number('drop_level_maximum'),
    },
    drop_leagues = {
        no_copy = true,
        field = 'drop_leagues',
        type = 'List (,) of String',
        func = m_util.cast.factory.assoc_table('drop_leagues', {tbl=m_game.constants.leagues, errmsg=i18n.errors.invalid_league}),
    },
    drop_areas = {
        no_copy = true,
        field = 'drop_areas',
        type = 'List (,) of String',
        func = function(tpl_args, frame)
            if tpl_args.drop_areas ~= nil then
                tpl_args.drop_areas = m_util.string.split(tpl_args.drop_areas, ',%s*')
                tpl_args.drop_areas_data = m_cargo.array_query{
                    tables={'areas'},
                    fields={'areas._pageName', 'areas.id', 'areas.name', 'areas.main_page'},
                    id_field='areas.id',
                    id_array=tpl_args.drop_areas,
                    query={limit=5000},
                }
            end
            
            -- find areas based on item tags for atlas bases
            local query_data
            for _, tag in ipairs(tpl_args.tags or {}) do
                query_data = nil
                if string.match(tag, '[%w_]*atlas[%w_]*') ~= nil and tag ~= 'atlas_base_type' then
                    query_data = m_cargo.query(
                        {'atlas_maps', 'maps', 'areas', 'atlas_base_item_types'},
                        {'areas._pageName', 'areas.id', 'areas.name', 'areas.main_page'},
                        {
                            join='atlas_maps._pageID=maps._pageID, maps.area_id=areas.id, atlas_maps.region_id=atlas_base_item_types.region_id',
                            where=string.format([[
                                    atlas_base_item_types.tag = "%s" 
                                    AND atlas_base_item_types.weight > 0 
                                    AND (
                                        atlas_maps.map_tier0 >= tier_min AND atlas_maps.map_tier0 <= atlas_base_item_types.tier_max
                                        OR atlas_maps.map_tier1 >= tier_min AND atlas_maps.map_tier1 <= atlas_base_item_types.tier_max
                                        OR atlas_maps.map_tier2 >= tier_min AND atlas_maps.map_tier2 <= atlas_base_item_types.tier_max
                                        OR atlas_maps.map_tier3 >= tier_min AND atlas_maps.map_tier3 <= atlas_base_item_types.tier_max
                                        OR atlas_maps.map_tier4 >= tier_min AND atlas_maps.map_tier4 <= atlas_base_item_types.tier_max
                                    )]],
                                tag),
                            groupBy='areas.id',
                        }
                    )
                end
                
                if query_data ~= nil then
                    -- in case no manual drop areas have been set
                    if tpl_args.drop_areas == nil then
                        tpl_args.drop_areas = {}
                        tpl_args.drop_areas_data = {}
                    end
                    local drop_areas_assoc = {}
                    for _, id in ipairs(tpl_args.drop_areas) do
                        drop_areas_assoc[id] = true
                    end
                    
                    local duplicates = {}
                    
                    for _, row in ipairs(query_data) do
                        if drop_areas_assoc[row['areas.id']] == nil then
                            tpl_args.drop_areas[#tpl_args.drop_areas+1] = row['areas.id']
                            tpl_args.drop_areas_data[#tpl_args.drop_areas_data+1] = row
                        else
                            duplicates[#duplicates+1] = row['areas.id']
                        end
                    end
                    
                    if #duplicates > 0 then
                        tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.duplicate_area_id_from_query, table.concat(duplicates, ', '))
                        tpl_args._flags.duplicate_query_area_ids = true
                    end
                end
            end
        end,
    },
    drop_monsters = {
        no_copy = true,
        field = 'drop_monsters',
        type = 'List (,) of Text',
        func = function (tpl_args, frame) 
            if tpl_args.drop_monsters ~= nil then
                tpl_args.drop_monsters = m_util.string.split(tpl_args.drop_monsters, ',%s*')
            end
        end,
    },
    drop_text = {
        no_copy = true,
        field = 'drop_text',
        type = 'Text',
        func = core.factory.cast_text('drop_text'),
    },
    required_level = {
        field = 'required_level_base',
        type = 'Integer',
        func = m_util.cast.factory.number('required_level'),
        default = 1,
    },
    required_level_final = {
        field = 'required_level',
        type = 'Integer',
        func = function(tpl_args, frame)
            tpl_args.required_level_final = tpl_args.required_level
        end,
        default = 1,
    },
    required_dexterity = {
        field = 'required_dexterity',
        type = 'Integer',
        func = m_util.cast.factory.number('required_dexterity'),
        default = 0,
    },
    required_strength = {
        field = 'required_strength',
        type = 'Integer',
        func = m_util.cast.factory.number('required_strength'),
        default = 0,
    },
    required_intelligence = {
        field = 'required_intelligence',
        type = 'Integer',
        func = m_util.cast.factory.number('required_intelligence'),
        default = 0,
    },
    inventory_icon = {
        no_copy = true,
        field = 'inventory_icon',
        type = 'String',
        func = function(tpl_args, frame)
            if tpl_args.class_id == 'DivinationCard' then
                tpl_args.inventory_icon = tpl_args.inventory_icon or 'Divination card'
            end
            tpl_args.inventory_icon_id = tpl_args.inventory_icon or tpl_args.name
            tpl_args.inventory_icon = string.format(i18n.inventory_icon, tpl_args.inventory_icon_id) 
        end,
    },
    -- note: this must be called after inventory item to work correctly as it depends on tpl_args.inventory_icon_id being set
    alternate_art_inventory_icons = {
        no_copy = true,
        field = 'alternate_art_inventory_icons',
        type = 'List (,) of String',
        func = function(tpl_args, frame)
            local icons = {}
            if tpl_args.alternate_art_inventory_icons ~= nil then
                local names = m_util.string.split(tpl_args.alternate_art_inventory_icons, ',%s*')
                
                for _, name in ipairs(names) do
                    icons[#icons+1] = string.format(i18n.inventory_icon, string.format('%s %s', tpl_args.inventory_icon_id, name))
                end
            end
            tpl_args.alternate_art_inventory_icons = icons
        end,
        default = function (tpl_args, frame) return {} end,
    },
    cannot_be_traded_or_modified = {
        no_copy = true,
        field = 'cannot_be_traded_or_modified',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('cannot_be_traded_or_modified'),
        default = false,
    },
    help_text = {
        debug_ignore_nil = true,
        field = 'help_text',
        type = 'Text',
        func = core.factory.cast_text('help_text'),
    },
    flavour_text = {
        no_copy = true,
        field = 'flavour_text',
        type = 'Text',
        func = core.factory.cast_text('flavour_text'),
    },
    flavour_text_id = {
        no_copy = true,
        field = 'flavour_text_id',
        type = 'String',
        func = nil,
    },
    tags = {
        field = 'tags',
        type = 'List (,) of String',
        func = m_util.cast.factory.assoc_table('tags', {
            tbl = m_game.constants.tags,
            errmsg = i18n.errors.invalid_tag,
        }),
    },
    metadata_id = {
        no_copy = true,
        field = 'metadata_id',
        type = 'String',
        --type = 'String(unique; size=200)',
        func = function(tpl_args, frame)
            if tpl_args.metadata_id == nil then
                return
            end
            local results = m_cargo.query(
                {'items'},
                {'items._pageName'},
                {
                    where=string.format('items.metadata_id="%s" AND items._pageName != "%s"', tpl_args.metadata_id, mw.title.getCurrentTitle().fullText)
                }
            )
            if #results > 0 and tpl_args.debug_id == nil and not tpl_args.debug then
                error(string.format(i18n.errors.duplicate_metadata, tpl_args.metadata_id, results[1]['items._pageName']))
            end
        end,
    },
    influences = {
        no_copy = true,
        field = 'influences',
        type = 'List (,) of String',
        func = m_util.cast.factory.assoc_table('influences', {
            tbl = m_game.constants.influences,
            errmsg = i18n.errors.invalid_influence,
        }),
    },
    is_fractured = {
        no_copy = true,
        field = 'is_fractured',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_fractured'),
        default = false,
    },
    is_synthesised = {
        no_copy = true,
        field = 'is_synthesised',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_synthesised'),
        default = false,
    },
    is_veiled = {
        no_copy = true,
        field = 'is_veiled',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_veiled'),
        default = false,
    },
    is_replica = {
        no_copy = true,
        field = 'is_replica',
        type = 'Boolean',
        func = function(tpl_args, frame)
            m_util.cast.factory.boolean('is_replica')(tpl_args, frame)
            if tpl_args.is_replica == true and tpl_args.rarity_id ~= 'unique' then
                error(string.format(i18n.errors.non_unique_flag, 'is_replica'))
            end
        end,
        default = false,
    },
    is_corrupted = {
        no_copy = true,
        field = 'is_corrupted',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_corrupted'),
        default = false,
    },
    is_relic = {
        no_copy = true,
        field = 'is_relic',
        type = 'Boolean',
        func = function(tpl_args, frame)
            m_util.cast.factory.boolean('is_relic')(tpl_args, frame)
            if tpl_args.is_relic == true and tpl_args.rarity_id ~= 'unique' then
                error(string.format(i18n.errors.non_unique_flag, 'is_relic'))
            end
        end,
        default = false,
    },
    is_fated = {
        no_copy = true,
        field = 'is_fated',
        type = 'Boolean',
        func = function(tpl_args, frame)
            m_util.cast.factory.boolean('is_fated')(tpl_args, frame)
            if tpl_args.is_fated == true and tpl_args.rarity_id ~= 'unique' then
                error(string.format(i18n.errors.non_unique_flag, 'is_fated'))
            end
        end,
        default = false,
    },
    is_prophecy = {
        no_copy = true,
        field = nil,
        type = nil,
        func = function(tpl_args, frame)
            tpl_args._flags.is_prophecy = (tpl_args.metadata_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' or tpl_args.base_item == 'Prophecy' or tpl_args.base_item_page == 'Prophecy' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy')
        end
    },
    is_blight_item = {
        no_copy = true,
        field = nil,
        type = nil,
        func = function(tpl_args, frame)
            tpl_args._flags.is_blight_item = (tpl_args.blight_item_tier ~= nil)
        end
    },
    is_drop_restricted = {
        no_copy  = true,
        field = 'is_drop_restricted',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_drop_restricted'),
        default = function(tpl_args, frame)
            -- Generally items that are obtained only from specific monsters can't be obtained via cards or other means unless specifically specified
            for _, var in ipairs({'is_talisman', 'is_fated', 'is_relic', 'drop_monsters'}) do
                if tpl_args[var] then
                    return true
                end
            end
            for _, flag in ipairs({'is_prophecy', 'is_blight_item'}) do
                if tpl_args._flags[flag] then
                    return true
                end
            end
            return false
        end,
    },
    purchase_costs = {
        func = function(tpl_args, frame)
            local purchase_costs = {}
            for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                local rtbl = {}
                local prefix = string.format('purchase_cost_%s', rarity_id)
                local i = 1
                while i ~= -1 do
                    local iprefix = prefix .. i
                    local values = {
                        name = tpl_args[iprefix .. '_name'],
                        amount = tonumber(tpl_args[iprefix .. '_amount']),
                        rarity = rarity_id,
                    }
                    if values.name ~= nil and values.amount ~= nil then
                        rtbl[#rtbl+1] = values
                        i = i + 1
                        
                        tpl_args._subobjects[#tpl_args._subobjects+1] = {
                            _table = 'item_purchase_costs',
                            amount = values.amount,
                            name = values.name,
                            rarity = values.rarity,
                        }
                    else
                        i = -1
                    end
                end
                
                purchase_costs[rarity_id] = rtbl
            end
            
            tpl_args.purchase_costs = purchase_costs
        end,
        func_fetch = function(tpl_args, frame)
            if tpl_args.rarity_id ~= 'unique' then
                return
            end
            
            local results = m_cargo.query(
                {'items' ,'item_purchase_costs'},
                {'item_purchase_costs.amount', 'item_purchase_costs.name', 'item_purchase_costs.rarity'},
                {
                    join = 'items._pageID=item_purchase_costs._pageID',
                    where = string.format('items._pageName="%s" AND item_purchase_costs.rarity="unique"', tpl_args.base_item_page),
                }
            )
            
            for _, row in ipairs(results) do
                local values = {
                    rarity = row['item_purchase_costs.rarity'],
                    name = row['item_purchase_costs.name'],
                    amount = tonumber(row['item_purchase_costs.amount']),
                }
                local datavar = tpl_args.purchase_costs[string.lower(values.rarity)]
                datavar[#datavar+1] = values
                
                tpl_args._subobjects[#tpl_args._subobjects+1] = {
                    _table = 'item_purchase_costs',
                    amount = values.amount,
                    name = values.name,
                    rarity = values.rarity,
                }
            end
        end,
    },
    sell_prices_override = {
        no_copy = true,
        func = function(tpl_args, frame)
            -- these variables are also used by mods when setting automatic sell prices
            tpl_args.sell_prices = {}
            tpl_args.sell_price_order = {}
            
            
            local name
            local amount
            local i = 0
            repeat
                i = i + 1
                name = tpl_args[string.format('sell_price%s_name', i)]
                amount = tpl_args[string.format('sell_price%s_amount', i)]
                
                if name ~= nil and amount ~= nil then
                    tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
                    tpl_args.sell_prices[name] = amount
                    tpl_args._subobjects[#tpl_args._subobjects+1] = {
                        _table = 'item_sell_prices',
                        amount = amount,
                        name = name,
                    }
                end
            until name == nil or amount == nil 
            
            -- if sell prices are set, the override is active
            for _, _ in pairs(tpl_args.sell_prices) do
                tpl_args._flags.sell_prices_override = true
                break
            end
        end,
    },
    --
    -- specific section
    --
    
    -- Most item classes
    quality = {
        no_copy = true,
        field = 'quality',
        type = 'Integer',
        -- Can be set manually, but default to Q20 for unique weapons/body armours
        -- Also must copy to stat for the stat adjustments to work properly
        func = function(tpl_args, frame)
            local quality = tonumber(tpl_args.quality)
            -- 
            if quality == nil then
                if tpl_args.rarity_id ~= 'unique' then
                    quality = 0
                elseif core.class_groups.weapons.keys[tpl_args.class_id] or core.class_groups.armor.keys[tpl_args.class_id] then
                    quality = 20
                else
                    quality = 0
                end
            end
            
            tpl_args.quality = quality
            
            local stat = {
                min = quality,
                max = quality,
                avg = quality,
            }
            
            h.stats_update(tpl_args, 'quality', stat, nil, '_stats')
            
            if tpl_args.class_id == 'UtilityFlask' or tpl_args.class_id == 'UtilityFlaskCritical' then
                h.stats_update(tpl_args, 'quality_flask_duration', stat, nil, '_stats')
            -- quality is added to quantity for maps
            elseif tpl_args.class_id == 'Map' then
                h.stats_update(tpl_args, 'map_item_drop_quantity_+%', stat, nil, '_stats')
            end
        end,
    },
    -- amulets
    is_talisman = {
        field = 'is_talisman',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_talisman'),
        default = false,
    },
    
    talisman_tier = {
        field = 'talisman_tier',
        type = 'Integer',
        func = m_util.cast.factory.number('talisman_tier'),
    },
    
    -- flasks
    charges_max = {
        field = 'charges_max',
        type = 'Integer',
        func = m_util.cast.factory.number('charges_max'),
    },
    charges_per_use = {
        field = 'charges_per_use',
        type = 'Integer',
        func = m_util.cast.factory.number('charges_per_use'),
    },
    flask_mana = {
        field = 'mana',
        type = 'Integer',
        func = m_util.cast.factory.number('flask_mana'),
    },
    flask_life = {
        field = 'life',
        type = 'Integer',
        func = m_util.cast.factory.number('flask_life'),
    },
    flask_duration = {
        field = 'duration',
        type = 'Float',
        func = m_util.cast.factory.number('flask_duration'),
    },
    buff_id = {
        field = 'id',
        type = 'String',
        func = nil,
    },
    buff_values = {
        field = 'buff_values',
        type = 'List (,) of Integer',
        func = function(tpl_args, frame)
            local values = {}
            local i = 0
            repeat 
                i = i + 1
                local key = 'buff_value' .. i
                values[i] = tonumber(tpl_args[key])
                tpl_args[key] = nil
            until values[i] == nil
            
            -- needed so the values copyied from unique item base isn't overriden
            if #values >= 1 then
                tpl_args.buff_values = values
            end
        end,
        func_copy = function(tpl_args, frame)
            tpl_args.buff_values = m_util.string.split(tpl_args.buff_values, ',%s*')
        end,
        default = function (tpl_args, frame) return {} end,
    },
    buff_stat_text = {
        field = 'stat_text',
        type = 'String',
        func = nil,
    },
    buff_icon = {
        field = 'icon',
        type = 'String',
        func = function(tpl_args, frame)
            tpl_args.buff_icon = string.format(i18n.status_icon, tpl_args.name) 
        end,
    },
    
    -- weapons
    critical_strike_chance = {
        field = 'critical_strike_chance',
        type = 'Float',
        func = m_util.cast.factory.number('critical_strike_chance'),
    },
    attack_speed = {
        field = 'attack_speed',
        type = 'Float',
        func = m_util.cast.factory.number('attack_speed'),
    },
    weapon_range = {
        field = 'weapon_range',
        type = 'Integer',
        func = m_util.cast.factory.number('weapon_range'),
    },
    physical_damage_min = {
        field = 'physical_damage_min',
        type = 'Integer',
        func = m_util.cast.factory.number('physical_damage_min'),
    },
    physical_damage_max = {
        field = 'physical_damage_max',
        type = 'Integer',
        func = m_util.cast.factory.number('physical_damage_max'),
    },
    fire_damage_min = {
        field = 'fire_damage_min',
        type = 'Integer',
        func = m_util.cast.factory.number('fire_damage_min'),
        default = 0,
    },
    fire_damage_max = {
        field = 'fire_damage_max',
        type = 'Integer',
        func = m_util.cast.factory.number('fire_damage_max'),
        default = 0,
    },
    cold_damage_min = {
        field = 'cold_damage_min',
        type = 'Integer',
        func = m_util.cast.factory.number('cold_damage_min'),
        default = 0,
    },
    cold_damage_max = {
        field = 'cold_damage_max',
        type = 'Integer',
        func = m_util.cast.factory.number('cold_damage_max'),
        default = 0,
    },
    lightning_damage_min = {
        field = 'lightning_damage_min',
        type = 'Integer',
        func = m_util.cast.factory.number('lightning_damage_min'),
        default = 0,
    },
    lightning_damage_max = {
        field = 'lightning_damage_max',
        type = 'Integer',
        func = m_util.cast.factory.number('lightning_damage_max'),
        default = 0,
    },
    chaos_damage_min = {
        field = 'chaos_damage_min',
        type = 'Integer',
        func = m_util.cast.factory.number('chaos_damage_min'),
        default = 0,
    },
    chaos_damage_max = {
        field = 'chaos_damage_max',
        type = 'Integer',
        func = m_util.cast.factory.number('chaos_damage_max'),
        default = 0,
    },
    -- armor-type stuff
    armour = {
        field = 'armour',
        type = 'Integer',
        func = m_util.cast.factory.number('armour'),
        default = 0,
    },
    energy_shield = {
        field = 'energy_shield',
        type = 'Integer',
        func = m_util.cast.factory.number('energy_shield'),
        default = 0,
    },
    evasion = {
        field = 'evasion',
        type = 'Integer',
        func = m_util.cast.factory.number('evasion'),
        default = 0,
    },
    -- This is the inherent penality from the armour piece if any
    movement_speed = {
        field = 'movement_speed',
        type = 'Integer',
        func = m_util.cast.factory.number('movement_speed'),
        default = 0,
    },
    -- shields
    block = {
        field = 'block',
        type = 'Integer',
        func = m_util.cast.factory.number('block'),
    },
    -- skill gem stuff
    gem_description = {
        field = 'gem_description',
        type = 'Text',
        func = core.factory.cast_text('gem_description'),
    },
    dexterity_percent = {
        field = 'dexterity_percent',
        type = 'Integer',
        func = m_util.cast.factory.percentage('dexterity_percent'),
    },
    strength_percent = {
        field = 'strength_percent',
        type = 'Integer',
        func = m_util.cast.factory.percentage('strength_percent'),
    },
    intelligence_percent = {
        field = 'intelligence_percent',
        type = 'Integer',
        func = m_util.cast.factory.percentage('intelligence_percent'),
    },
    primary_attribute = {
        field = 'primary_attribute',
        type = 'String',
        func = function(tpl_args, frame)
            for _, attr in ipairs(m_game.constants.attribute_order) do
                local val = tpl_args[attr .. '_percent'] 
                if val and val >= 60 then
                    tpl_args['primary_attribute'] = attr
                    return
                end
            end
            tpl_args['primary_attribute'] = 'none'
        end,
    },
    gem_tags = {
        field = 'gem_tags',
        type = 'List (,) of String',
        -- TODO: default rework
        func = function(tpl_args, frame)
            if tpl_args.gem_tags then
                tpl_args.gem_tags = m_util.string.split(tpl_args.gem_tags, ',%s*')
            end
        end,
        default = function (tpl_args, frame) return {} end,
    },
    -- Support gems only
    support_gem_letter = {
        field = 'support_gem_letter',
        type = 'String(size=1)',
        func = nil,
    },
    support_gem_letter_html = {
        field = 'support_gem_letter_html',
        type = 'Text',
        func = function(tpl_args, frame)
            if tpl_args.support_gem_letter == nil then
                return
            end
        
            -- TODO replace this with a loop possibly
            local css_map = {
                strength = 'red',
                intelligence = 'blue',
                dexterity = 'green',
            }
            local id
            for k, v in pairs(css_map) do
                k = string.format('%s_percent', k)
                if tpl_args[k] and tpl_args[k] > 50 then
                    id = v
                    break
                end
            end
            
            if id ~= nil then
                local container = mw.html.create('span')
                container
                    :attr('class', string.format('support-gem-id-%s', id))
                    :wikitext(tpl_args.support_gem_letter)
                    :done()
                tpl_args.support_gem_letter_html = tostring(container)
            end
        end,
    },
    --
    -- Maps
    --
    map_tier = {
        field = 'tier',
        type = 'Integer',
        func = m_util.cast.factory.number('map_tier'),
    },
    map_guild_character = {
        field = 'guild_character',
        type = 'String(size=1)',
        func = nil,
    },
    map_area_id = {
        field = 'area_id',
        type = 'String',
        func = nil, -- TODO: Validate against a query?
    },
    map_area_level = {
        field = 'area_level',
        type = 'Integer',
        func = m_util.cast.factory.number('map_area_level'),
    },
    unique_map_guild_character = {
        field = 'unique_guild_character',
        type = 'String(size=1)',
        func_copy = function(tpl_args, frame)
            tpl_args.map_guild_character = tpl_args.unique_map_guild_character
        end,
        func = nil,
    },
    unique_map_area_id = {
        field = 'unique_area_id',
        type = 'String',
        func = nil, -- TODO: Validate against a query?
        func_copy = function(tpl_args, frame)
            tpl_args.map_area_id = tpl_args.unique_map_area_id
        end,
    },
    unique_map_area_level = {
        field = 'unique_area_level',
        type = 'Integer',
        func = m_util.cast.factory.number('unique_map_area_level'),
        func_copy = function(tpl_args, frame)
            tpl_args.map_area_level = tpl_args.unique_map_area_level
        end,
    },
    map_series = {
        field = 'series',
        type = 'String',
        func = function(tpl_args, frame)
            if tpl_args.rarity == 'normal' and tpl_args.map_series == nil then
                error(string.format(i18n.errors.generic_required_parameter, 'map_series'))
            end
        end,
    },
    -- atlas info is only for the current map series
    atlas_x = {
        field = 'x',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x'),
    },
    atlas_y = {
        field = 'y',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_y'),
    },
    atlas_region_id = {
        field = 'region_id',
        type = 'String',
        func = nil,
    },
    atlas_region_minimum = {
        field = 'region_minimum',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_region_minimum'),
    },
    atlas_x0 = {
        field = 'x0',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x0'),
    },
    atlas_x1 = {
        field = 'x1',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x1'),
    },
    atlas_x2 = {
        field = 'x2',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x2'),
    },
    atlas_x3 = {
        field = 'x3',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x3'),
    },
    atlas_x4 = {
        field = 'x4',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_x4'),
    },
    atlas_y0 = {
        field = 'y0',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_0'),
    },
    atlas_y1 = {
        field = 'y1',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_y1'),
    },
    atlas_y2 = {
        field = 'y2',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_y2'),
    },
    atlas_y3 = {
        field = 'y3',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_y3'),
    },
    atlas_y4 = {
        field = 'y4',
        type = 'Float',
        func = m_util.cast.factory.number('atlas_y4'),
    },
    atlas_map_tier0 = {
        field = 'map_tier0',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_map_tier0'),
    },
    atlas_map_tier1 = {
        field = 'map_tier1',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_map_tier1'),
    },
    atlas_map_tier2 = {
        field = 'map_tier2',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_map_tier2'),
    },
    atlas_map_tier3 = {
        field = 'map_tier3',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_map_tier3'),
    },
    atlas_map_tier4 = {
        field = 'map_tier4',
        type = 'Integer',
        func = m_util.cast.factory.number('atlas_map_tier4'),
    },
    atlas_connections = {
        field = nil,
        type = nil,
        func = function(tpl_args, frame)
            tpl_args.atlas_connections = {}
            
            local cont = true
            local i = 1
            while cont do
                local prefix = string.format('atlas_connection%s_', i)
                local regions = tpl_args[prefix .. 'tier']
                local data = {
                    _table = 'atlas_connections',
                    map1 = string.format('%s (%s)', tpl_args.name, tpl_args.map_series or ''),
                    map2 = tpl_args[prefix .. 'target'],
                }
                
                if regions and data.map2 then
                    regions = m_util.string.split(regions, ',%s*')
                    if #regions ~= 5 then
                        error(string.format(i18n.errors.invalid_region_upgrade_count, i, #regions))
                    end
                    for index, value in ipairs(regions) do
                        data['region' .. (index - 1)] = m_util.cast.boolean(value)
                    end
                    
                    tpl_args.atlas_connections[data.map2] = data
                    table.insert(tpl_args._subobjects, data)
                else
                    cont = false
                    if i == 1 then
                        tpl_args.atlas_connections = nil
                    end
                end
                
                i = i + 1
            end
        end,
        default = nil,
    },
    --
    -- Currency-like items
    --
    stack_size = {
        field = 'stack_size',
        type = 'Integer',
        func = m_util.cast.factory.number('stack_size'),
    },
    stack_size_currency_tab = {
        field = 'stack_size_currency_tab',
        type = 'Integer',
        func = m_util.cast.factory.number('stack_size_currency_tab'),
    },
    description = {
        field = 'description',
        type = 'Text',
        func = core.factory.cast_text('description'),
    },
    cosmetic_type = {
        field = 'cosmetic_type',
        type = 'String',
        func = core.factory.cast_text('cosmetic_type'),
    },
    -- for essences
    is_essence = {
        field = nil,
        func = m_util.cast.factory.boolean('is_essence'),
        default = false,
    },
    essence_level_restriction = {
        field = 'level_restriction',
        type = 'Integer',
        func = m_util.cast.factory.number('essence_level_restriction'),
    },
    essence_level = {
        field = 'level',
        type = 'Integer',
        func = m_util.cast.factory.number('essence_level'),
    },
    essence_type = {
        field = 'type',
        type = 'Integer',
        func = m_util.cast.factory.number('essence_type'),
    },
    essence_category = {
        field = 'category',
        type = 'String',
        func = nil,
    },
    -- blight crafting items (i.e. oils)
    blight_item_tier = {
        field = 'tier',
        type = 'Integer',
        func = m_util.cast.factory.number('blight_item_tier'),
    },
    -- harvest seeds
    seed_type_id = {
        field = 'type_id',
        type = 'String',
    },
    seed_type = {
        field = 'type',
        type = 'String',
        func = function (tpl_args, frame)
            if tpl_args.seed_type_id ~= 'none' or tpl_args.seed_type_id ~= nil then
                tpl_args.seed_type = m_game.seed_types[tpl_args.seed_type_id]
            end
        end
    },
    seed_type_html = {
        field = nil,
        type = nil,
        func = function (tpl_args, frame)
            if tpl_args.seed_type ~= nil then
                tpl_args.seed_type_html = m_util.html.poe_color(tpl_args.seed_type_id, tpl_args.seed_type)
            end
        end
    },
    seed_effect = {
        field = 'effect',
        type = 'Text',
    },
    seed_tier = {
        field = 'tier',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_tier'),
    },
    seed_growth_cycles = {
        field = 'growth_cycles',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_growth_cycles'),
    },
    seed_required_nearby_seed_tier = {
        field = 'required_nearby_seed_tier',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_required_nearby_seed_tier'),
    },
    seed_required_nearby_seed_amount = {
        field = 'required_nearby_seed_amount',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_required_nearby_seed_amount'),
    },
    seed_consumed_wild_lifeforce_percentage = {
        field = 'consumed_wild_lifeforce_percentage',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_consumed_wild_lifeforce_percentage'),
        default = 0,
    },
    seed_consumed_vivid_lifeforce_percentage = {
        field = 'consumed_vivid_lifeforce_percentage',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_consumed_vivid_lifeforce_percentage'),
        default = 0,
    },
    seed_consumed_primal_lifeforce_percentage = {
        field = 'consumed_primal_lifeforce_percentage',
        type = 'Integer',
        func = m_util.cast.factory.number('seed_consumed_primal_lifeforce_percentage'),
        default = 0,
    },
    seed_granted_craft_option_ids = {
        field = 'granted_craft_option_ids',
        type = 'List (,) of String',
        func = m_util.cast.factory.number('seed_grandted_craft_option_ids'),
        default = 0,
    },
    --
    -- harvest planet boosters
    --
    plant_booster_radius = {
        field = 'radius',
        type = 'Integer',
        func = m_util.cast.factory.number('plant_booster_radius'),
    },
    plant_booster_lifeforce = {
        field = 'lifeforce',
        type = 'Integer',
        func = m_util.cast.factory.number('plant_booster_lifeforce'),
    },
    plant_booster_additional_crafting_options = {
        field = 'additional_crafting_options',
        type = 'Integer',
        func = m_util.cast.factory.number('plant_booster_additional_crafting_options'),
    },
    plant_booster_extra_chances = {
        field = 'extra_chances',
        type = 'Integer',
        func = m_util.cast.factory.number('plant_booster_extra_chances'),
    },
    --
    -- Heist properties
    --
    heist_required_job_id = {
        field = 'required_job_id',
        type = 'String',
        func = core.factory.cast_text('heist_required_job_id'),
    },
    heist_required_job_level = {
        field = 'required_job_level',
        type = 'Integer',
        func = m_util.cast.factory.number('heist_required_job_level'),
    },
    heist_data = {
        func = function (tpl_args, frame)
            if tpl_args.heist_required_job_level then
                if tpl_args.heist_required_job_id then
                    local results = m_cargo.query(
                        {'heist_jobs', 'heist_npcs', 'heist_npc_skills'},
                        {'heist_npcs.name', 'heist_jobs.name'},
                        {
                            join = 'heist_npc_skills.job_id=heist_jobs.id, heist_npc_skills.npc_id=heist_npcs.id',
                            where = string.format('heist_npc_skills.job_id = "%s" AND heist_npc_skills.level >= %s', tpl_args.heist_required_job_id, tpl_args.heist_required_job_level),
                        }
                    )
                    
                    local npcs = {}
                    
                    for _, row in ipairs(results) do
                        npcs[#npcs+1] = row['heist_npcs.name']
                    end
                    
                    tpl_args.heist_required_npcs = table.concat(npcs, ', ')
                    tpl_args.heist_required_job = results[1]['heist_jobs.name']
                else
                    tpl_args.heist_required_job = i18n.tooltips.heist_any_job
                end
            end
        end,
    },
    --
    -- hideout doodads (HideoutDoodads.dat)
    --
    is_master_doodad = {
        field = 'is_master_doodad',
        type = 'Boolean',
        func = m_util.cast.factory.boolean('is_master_doodad'),
    },
    master = {
        field = 'master',
        type = 'String',
        -- todo validate against list of master names
        func = m_util.cast.factory.table('master', {key='full', tbl=m_game.constants.masters}),
    },
    master_level_requirement = {
        field = 'level_requirement',
        type = 'Integer',
        func = m_util.cast.factory.number('master_level_requirement'),
    },
    master_favour_cost = {
        field = 'favour_cost',
        type = 'Integer',
        func = m_util.cast.factory.number('master_favour_cost'),
    },
    variation_count = {
        field = 'variation_count',
        type = 'Integer',
        func = m_util.cast.factory.number('variation_count'),
    },
    -- Propehcy
    prophecy_id = {
        field = 'prophecy_id',
        type = 'String',
        func = nil,
    },
    prediction_text = {
        field = 'prediction_text',
        type = 'Text',
        func = core.factory.cast_text('prediction_text'),
    },
    seal_cost = {
        field = 'seal_cost',
        type = 'Integer',
        func = m_util.cast.factory.number('seal_cost'),
    },
    prophecy_reward = {
        field = 'reward',
        type = 'Text',
        func = core.factory.cast_text('prophecy_reward'),
    },
    prophecy_objective = {
        field = 'objective',
        type = 'Text',
       func = core.factory.cast_text('prophecy_objective'),
    },
    -- Divination cards
    card_art = {
        field = 'card_art',
        type = 'Page',
        func = function(tpl_args, frame)
            tpl_args.card_art = string.format(i18n.divination_card_art, tpl_args.card_art or tpl_args.name)
        end,
    },
    -- ------------------------------------------------------------------------
    -- derived stats
    -- ------------------------------------------------------------------------
    
    -- For rarity != normal, rarity already verified
    base_item = {
        no_copy = true,
        field = 'base_item',
        type = 'String',
        func = function(tpl_args, frame)
            tpl_args.base_item = tpl_args.base_item_data['items.name']
        end,
    },
    base_item_id = {
        no_copy = true,
        field = 'base_item_id',
        type = 'String',
        func = function(tpl_args, frame)
            tpl_args.base_item_id = tpl_args.base_item_data['items.metadata_id']
        end,
    },
    base_item_page = {
        no_copy = true,
        field = 'base_item_page',
        type = 'Page',
        func = function(tpl_args, frame)
            tpl_args.base_item_page = tpl_args.base_item_data['items._pageName']
        end,
    },
    name_list = {
        no_copy = true,
        field = 'name_list',
        type = 'List (�) of String',
        func = function(tpl_args, frame)
            if tpl_args.name_list ~= nil then
                tpl_args.name_list = m_util.string.split(tpl_args.name_list, ',%s*')
                tpl_args.name_list[#tpl_args.name_list+1] = tpl_args.name
            else
                tpl_args.name_list = {tpl_args.name}
            end
        end,
    },
    frame_type = {
        no_copy = true,
        field = 'frame_type',
        type = 'String',
        property = nil,
        func = function(tpl_args, frame)
            if tpl_args._flags.is_prophecy then
                tpl_args.frame_type = 'prophecy'
                return
            end
        
            local var = core.class_specifics[tpl_args.class_id]
            if var ~= nil and var.frame_type ~= nil then
                tpl_args.frame_type = var.frame_type
                return
            end
            
            if tpl_args.is_relic then
                tpl_args.frame_type = 'relic'
                return
            end
            
            tpl_args.frame_type = tpl_args.rarity_id
        end,
    },
    --
    -- args populated by mod validation
    -- 
    mods = {
        default = function (tpl_args, frame) return {} end,
        func_fetch = function (tpl_args, frame)
            local results = m_cargo.query(
                {'items' ,'item_mods'},
                {'item_mods.id', 'item_mods.is_implicit', 'item_mods.is_random', 'item_mods.text'},
                {
                    join = 'items._pageID=item_mods._pageID',
                    where = string.format('items._pageName="%s" AND item_mods.is_implicit=1', tpl_args.base_item_page),
                }
            )
            for _, row in ipairs(results) do
                -- Handle text-only mods
                local result
                if row['item_mods.id'] == nil then
                    result = row['item_mods.text']
                end
                tpl_args._mods[#tpl_args._mods+1] = {
                    result=result,
                    id=row['item_mods.id'],
                    stat_text=row['item_mods.text'],
                    is_implicit=m_util.cast.boolean(row['item_mods.is_implicit']),
                    is_random=m_util.cast.boolean(row['item_mods.is_random']),
                }
            end
        end,
    },
    physical_damage_html = {
        no_copy = true,
        field = 'physical_damage_html',
        type = 'Text',
        func = core.factory.damage_html{key='physical'},
    },
    fire_damage_html = {
        no_copy = true,
        field = 'fire_damage_html',
        type = 'Text',
        func = core.factory.damage_html{key='fire'},
    },
    cold_damage_html = {
        no_copy = true,
        field = 'cold_damage_html',
        type = 'Text',
        func = core.factory.damage_html{key='cold'},
    },
    lightning_damage_html = {
        no_copy = true,
        field = 'lightning_damage_html',
        type = 'Text',
        func = core.factory.damage_html{key='lightning'},
    },
    chaos_damage_html = {
        no_copy = true,
        field = 'chaos_damage_html',
        type = 'Text',
        func = core.factory.damage_html{key='chaos'},
    },
    damage_avg = {
        no_copy = true,
        field = 'damage_avg',
        type = 'Text',
        func = function(tpl_args, frame)
            local dmg = {min=0, max=0}
            for key, _ in pairs(dmg) do
                for _, dkey in ipairs(m_game.constants.damage_type_order) do
                    dmg[key] = dmg[key] + tpl_args[string.format('%s_damage_%s_range_average', dkey, key)]
                end
            end
            
            dmg = (dmg.min + dmg.max) / 2
            
            tpl_args.damage_avg = dmg
        end,
    },
    damage_html = {
        no_copy = true,
        field = 'damage_html',
        type = 'Text',
        func = function(tpl_args, frame)
            local text = {}
            for _, dkey in ipairs(m_game.constants.damage_type_order) do
                local value = tpl_args[dkey .. '_damage_html']
                if value ~= nil then
                    text[#text+1] = value
                end
            end
            if #text > 0 then
                tpl_args.damage_html = table.concat(text, '<br>')
            end
        end,
    },
    item_limit = {
        no_copy = true,
        field = 'item_limit',
        type = 'Integer',
        func = m_util.cast.factory.number('item_limit'),
    },
    jewel_radius_html = {
        no_copy = true,
        field = 'radius_html',
        type = 'Text',
        func = function(tpl_args, frame)
            local radius = tpl_args._stats.local_jewel_effect_base_radius
            if radius then
                radius = radius.min
                tpl_args.jewel_radius_html = string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[radius] or '?'), radius)
            end
        end,
    },
    incubator_effect = {
        no_copy = true,
        field = 'effect',
        type = 'Text',
        func = nil,
    },
    drop_areas_html = {
        no_copy = true,
        field = 'drop_areas_html',
        type = 'Text',
        func = function(tpl_args, frame)
            if tpl_args.drop_areas_data == nil then
                return
            end
            
            if tpl_args.drop_areas_html ~= nil then
                return
            end
            
            local areas = {}
            for _, data in pairs(tpl_args.drop_areas_data) do
                -- skip legacy maps in the drop html listing
                if not string.match(data['areas.id'], '^Map.*') or string.match(data['areas.id'], '^MapWorlds.*') or string.match(data['areas.id'], '^MapAtziri.*') then
                    areas[#areas+1] = string.format('[[%s|%s]]', data['areas.main_page'] or data['areas._pageName'], data['areas.main_page'] or data['areas.name'])
                end
            end
            
            tpl_args.drop_areas_html = table.concat(areas, ' • ')
        end,
    },
    release_version = {
        no_copy = true,
        field = 'release_version',
        type = 'String'
    },
    removal_version = {
        no_copy = true,
        field = 'removal_version',
        type = 'String',
    },
    --
    -- args governing use of the template itself
    -- 
    suppress_improper_modifiers_category = {
        no_copy = true,
        field = nil,
        func = m_util.cast.factory.boolean('suppress_improper_modifiers_category'),
        default = false,
    },
    upgraded_from_disabled = {
        no_copy = true,
        field = nil,
        func = m_util.cast.factory.boolean('upgraded_from_disabled'),
        default = false,
    },
}

core.stat_map = {
    required_level_final = {
        field = 'required_level',
        stats_add = {
            'local_level_requirement_+',
        },
        stats_override = {
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=1, max=1},
        },
        minimum = 1,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    weapon_range = {
        field = 'weapon_range',
        stats_add = {
            'local_weapon_range_+',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    physical_damage_min = {
        field = 'physical_damage_min',
        stats_add = {
            'local_minimum_added_physical_damage',
        },
        stats_increased = {
            'local_physical_damage_+%',
            'quality',
        },
        stats_override = {
            ['local_weapon_no_physical_damage'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    physical_damage_max = {
        field = 'physical_damage_max',
        stats_add = {
            'local_maximum_added_physical_damage',
        },
        stats_increased = {
            'local_physical_damage_+%',
            'quality',
        },
        stats_override = {
            ['local_weapon_no_physical_damage'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    fire_damage_min = {
        field = 'fire_damage_min',
        stats_add = {
            'local_minimum_added_fire_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'fire',
            fmt = '%i',
        },
    },
    fire_damage_max = {
        field = 'fire_damage_max',
        stats_add = {
            'local_maximum_added_fire_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'fire',
            fmt = '%i',
        },
    },
    cold_damage_min = {
        field = 'cold_damage_min',
        stats_add = {
            'local_minimum_added_cold_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'cold',
            fmt = '%i',
        },
    },
    cold_damage_max = {
        field = 'cold_damage_max',
        stats_add = {
            'local_maximum_added_cold_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'cold',
            fmt = '%i',
        },
    },
    lightning_damage_min = {
        field = 'lightning_damage_min',
        stats_add = {
            'local_minimum_added_lightning_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'lightning',
            fmt = '%i',
        },
    },
    lightning_damage_max = {
        field = 'lightning_damage_max',
        stats_add = {
            'local_maximum_added_lightning_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'lightning',
            fmt = '%i',
        },
    },
    chaos_damage_min = {
        field = 'chaos_damage_min',
        stats_add = {
            'local_minimum_added_chaos_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'chaos',
            fmt = '%i',
        },
    },
    chaos_damage_max = {
        field = 'chaos_damage_max',
        stats_add = {
            'local_maximum_added_chaos_damage',
        },
        minimum = 0,
        html_fmt_options = {
            color = 'chaos',
            fmt = '%i',
        },
    },
    critical_strike_chance = {
        field = 'critical_strike_chance',
        stats_add = {
            'local_critical_strike_chance',
        },
        stats_increased = {
            'local_critical_strike_chance_+%',
        },
        stats_override = {
            ['local_weapon_always_crit'] = {min=100, max=100},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%.2f%%',
        },
    },
    attack_speed = {
        field = 'attack_speed',
        stats_increased = {
            'local_attack_speed_+%',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%.2f',
        },
    },
    flask_life = {
        field = 'life',
        stats_add = {
            'local_flask_life_to_recover',
        },
        stats_increased = {
            'local_flask_life_to_recover_+%',
            'local_flask_amount_to_recover_+%',
            'quality',
        },
        html_fmt_options = {
            fmt = '%i',
        },
    },
    flask_mana = {
        field = 'mana',
        stats_add = {
            'local_flask_mana_to_recover',
        },
        stats_increased = {
            'local_flask_mana_to_recover_+%',
            'local_flask_amount_to_recover_+%',
            'quality',
        },
    },
    flask_duration = {
        field = 'duration',
        stats_increased = {
            'local_flask_duration_+%',
            -- regular quality isn't used here because it doesn't increase duration of life/mana/hybrid flasks
            'quality_flask_duration',
        },
        stats_increased_inverse = {
            'local_flask_recovery_speed_+%',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%.2f',
        },
    },
    charges_per_use = {
        field = 'charges_per_use',
        stats_increased = {
            'local_charges_used_+%',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    charges_max = {
        field = 'charges_max',
        stats_add = {
            'local_extra_max_charges',
        },
        stats_increased = {
            'local_max_charges_+%',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    block = {
        field = 'block',
        stats_add = {
            'local_additional_block_chance_%',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i%%',
        },
    },
    armour = {
        field = 'armour',
        stats_add = {
            'local_base_physical_damage_reduction_rating',
        },
        stats_increased = {
            'local_physical_damage_reduction_rating_+%',
            'local_armour_and_energy_shield_+%',
            'local_armour_and_evasion_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
            'quality',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    evasion = {
        field = 'evasion',
        stats_add = {
            'local_base_evasion_rating',
            'local_evasion_rating_and_energy_shield',
        },
        stats_increased = {
            'local_evasion_rating_+%',
            'local_evasion_and_energy_shield_+%',
            'local_armour_and_evasion_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
            'quality',
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    energy_shield = {
        field = 'energy_shield',
        stats_add = {
            'local_energy_shield',
            'local_evasion_rating_and_energy_shield',
        },
        stats_increased = {
            'local_energy_shield_+%',
            'local_armour_and_energy_shield_+%',
            'local_evasion_and_energy_shield_+%',
            'local_armour_and_evasion_and_energy_shield_+%',
            'quality',
        },
        stats_override = {
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    required_dexterity = {
        field = 'required_dexterity',
        stats_add = {
            'local_dexterity_requirement_+'
        },
        stats_increased = {
            'local_dexterity_requirement_+%',
            'local_attribute_requirements_+%',
        },
        stats_override = {
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
            ['local_no_attribute_requirements'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    required_intelligence = {
        field = 'required_intelligence',
        stats_add = {
            'local_intelligence_requirement_+'
        },
        stats_increased = {
            'local_intelligence_requirement_+%',
            'local_attribute_requirements_+%',
        },
        stats_override = {
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
            ['local_no_attribute_requirements'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    required_strength = {
        field = 'required_strength',
        stats_add = {
            'local_strength_requirement_+'
        },
        stats_increased = {
            'local_strength_requirement_+%',
            'local_attribute_requirements_+%',
        },
        stats_override = {
            ['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
            ['local_no_attribute_requirements'] = {min=0, max=0},
        },
        minimum = 0,
        html_fmt_options = {
            fmt = '%i',
        },
    },
    map_area_level = {
        field = 'map_area_level',
        stats_override = {
            ['map_item_level_override'] = true,
        },
    },
}

core.dps_map = {
    {
        name = 'physical_dps',
        field = 'physical_dps',
        damage_args = {'physical_damage', },
        label_infobox = i18n.tooltips.physical_dps,
        html_fmt_options = {
            color = 'value',
            fmt = '%.1f',
        },
    },
    {
        name = 'fire_dps',
        field = 'fire_dps',
        damage_args = {'fire_damage'},
        label_infobox = i18n.tooltips.fire_dps,
        html_fmt_options = {
            color = 'fire',
            fmt = '%.1f',
        },
    },
    {
        name = 'cold_dps',
        field = 'cold_dps',
        damage_args = {'cold_damage'},
        label_infobox = i18n.tooltips.cold_dps,
        html_fmt_options = {
            color = 'cold',
            fmt = '%.1f',
        },
    },
    {
        name = 'lightning_dps',
        field = 'lightning_dps',
        damage_args = {'lightning_damage'},
        label_infobox = i18n.tooltips.lightning_dps,
        html_fmt_options = {
            color = 'lightning',
            fmt = '%.1f',
        },
    },
    {
        name = 'chaos_dps',
        field = 'chaos_dps',
        damage_args = {'chaos_damage'},
        label_infobox = i18n.tooltips.chaos_dps,
        html_fmt_options = {
            color = 'chaos',
            fmt = '%.1f',
        },
    },
    {
        name = 'elemental_dps',
        field = 'elemental_dps',
        damage_args = {'fire_damage', 'cold_damage', 'lightning_damage'},
        label_infobox = i18n.tooltips.elemental_dps,
        html_fmt_options = {
            color = 'value',
            fmt = '%.1f',
        },
    },
    {
        name = 'poison_dps',
        field = 'poison_dps',
        damage_args = {'physical_damage', 'chaos_damage'},
        label_infobox = i18n.tooltips.poison_dps,
        html_fmt_options = {
            color = 'value',
            fmt = '%.1f',
        },
    },
    {
        name = 'dps',
        field = 'dps',
        damage_args = {'physical_damage', 'fire_damage', 'cold_damage', 'lightning_damage', 'chaos_damage'},
        label_infobox = i18n.tooltips.dps,
        html_fmt_options = {
            color = 'value',
            fmt = '%.1f',
        },
    },
}

core.cargo = {}
core.cargo.items = {
    table = 'items',
    fields = {
        html = core.map.html,
        html_extra = core.map.html_extra,
        implicit_stat_text = core.map.implicit_stat_text,
        explicit_stat_text = core.map.explicit_stat_text,
        stat_text = core.map.stat_text,
        class = core.map.class,
        class_id = core.map.class_id,
        rarity = core.map.rarity,
        rarity_id = core.map.rarity_id,
        name = core.map.name,
        size_x = core.map.size_x,
        size_y = core.map.size_y,
        drop_enabled = core.map.drop_enabled,
        drop_level = core.map.drop_level,
        drop_level_maximum = core.map.drop_level_maximum,
        drop_leagues = core.map.drop_leagues,
        drop_areas = core.map.drop_areas,
        drop_areas_html = core.map.drop_areas_html,
        drop_monsters = core.map.drop_monsters,
        drop_text = core.map.drop_text,
        -- sightly different because of strange DB issues
        drop_rarity_ids = core.map.drop_rarities_ids,
        required_level = core.map.required_level,
        required_level_final = core.map.required_level_final,
        required_dexterity = core.map.required_dexterity,
        required_strength = core.map.required_strength,
        required_intelligence = core.map.required_intelligence,
        inventory_icon = core.map.inventory_icon,
        alternate_art_inventory_icons = core.map.alternate_art_inventory_icons,
        buff_icon = core.map.buff_icon,
        cannot_be_traded_or_modified = core.map.cannot_be_traded_or_modified,
        help_text = core.map.help_text,
        flavour_text = core.map.flavour_text,
        flavour_text_id = core.map.flavour_text_id,
        tags = core.map.tags,
        metadata_id = core.map.metadata_id,
        influences = core.map.influences,
        is_fractured = core.map.is_fractured,
        is_synthesised = core.map.is_synthesised,
        is_veiled = core.map.is_veiled,
        is_replica = core.map.is_replica,
        is_corrupted = core.map.is_corrupted,
        is_relic = core.map.is_relic,
        is_fated = core.map.is_fated,
        is_drop_restricted = core.map.is_drop_restricted,
        quality = core.map.quality,
        base_item = core.map.base_item,
        base_item_id = core.map.base_item_id,
        base_item_page = core.map.base_item_page,
        frame_type = core.map.frame_type,
        name_list = core.map.name_list,
        description = core.map.description,
        release_version = core.map.release_version,
        removal_version = core.map.removal_version,
    },
}

core.cargo.item_sell_prices = {
    table = 'item_sell_prices',
    fields = {
        amount = {
            field = 'amount',
            type = 'Integer',
        },
        name = {
            field = 'name',
            type = 'String',
        },
    },
}


core.cargo.item_purchase_costs = {
    table = 'item_purchase_costs',
    fields = {
        amount = {
            field = 'amount',
            type = 'Integer',
        },
        name = {
            field = 'name',
            type = 'String',
        },
        rarity = {
            field = 'rarity',
            type = 'String',
        },
    },
}

core.cargo.item_mods = {
    table = 'item_mods',
    fields = {
        id = {
            field = 'id',
            type = 'String',
        },
        stat_text = {
            field = 'text',
            type = 'Text',
        },
        is_implicit = {
            field = 'is_implicit',
            type = 'Boolean',
        },
        is_random = {
            field = 'is_random',
            type = 'Boolean',
        },
    },
}

core.cargo.item_stats = {
    table = 'item_stats',
    fields = {
        id = {
            field = 'id',
            type = 'String',
        },
        min = {
            field = 'min',
            type = 'Integer',
        },
        max = {
            field = 'max',
            type = 'Integer',
        },
        avg = {
            field = 'avg',
            type = 'Integer',
        },
        is_implicit = {
            field = 'is_implicit',
            type = 'Boolean',
        },
        is_random = {
            field = 'is_random',
            type = 'Boolean',
        },
    },
}

-- There probably will be a table named "buffs" in the future, so "item_buffs" is the best solution here
core.cargo.item_buffs = {
    table = 'item_buffs',
    fields = {
        id = core.map.buff_id,
        buff_values = core.map.buff_values,
        stat_text = core.map.buff_stat_text,
        icon = core.map.buff_icon,
    },
}

core.cargo.upgraded_from_sets = {
    table = 'upgraded_from_sets',
    fields = {
        set_id = {
            field = 'set_id',
            type = 'Integer',
        },
        text = {
            field = 'text',
            type = 'Text',
        },
        automatic = {
            field = 'automatic',
            type = 'Boolean',
        },
    }
}

core.cargo.upgraded_from_groups = {
    table = 'upgraded_from_groups',
    fields = {
        group_id = {
            field = 'group_id',
            type = 'Integer',
        },
        set_id = {
            field = 'set_id',
            type = 'Integer',
        },
        item_id = {
            field = 'item_id',
            type = 'String',
        },
        item_name = {
            field = 'item_name',
            type = 'String',
        },
        item_page = {
            field = 'item_page',
            type = 'Page',
        },
        integer = {
            field = 'amount',
            type = 'Integer',
        },
        notes = {
            field = 'notes',
            type = 'Text',
        },
    }
}

core.cargo.amulets = {
    table = 'amulets',
    fields = {
        is_talisman = core.map.is_talisman,
        talisman_tier = core.map.talisman_tier,
    },
}

core.cargo.flasks = {
    table = 'flasks',
    fields = {
        -- All flasks
        duration = core.map.flask_duration,
        charges_max = core.map.charges_max,
        charges_per_use = core.map.charges_per_use,
        -- Life/Mana/Hybrid flasks
        life = core.map.flask_life,
        mana = core.map.flask_mana,
    },
}

core.cargo.weapons = {
    table = 'weapons',
    fields = {
        critical_strike_chance = core.map.critical_strike_chance,
        attack_speed = core.map.attack_speed,
        weapon_range = core.map.weapon_range,
        physical_damage_min = core.map.physical_damage_min,
        physical_damage_max = core.map.physical_damage_max,
        physical_damage_html = core.map.physical_damage_html,
        fire_damage_html = core.map.fire_damage_html,
        cold_damage_html = core.map.cold_damage_html,
        lightning_damage_html = core.map.lightning_damage_html,
        chaos_damage_html = core.map.chaos_damage_html,
        damage_avg = core.map.damage_avg,
        damage_html = core.map.damage_html,
        
        -- Values added via stat population
        fire_damage_min = core.map.fire_damage_min,
        fire_damage_max = core.map.fire_damage_max,
        cold_damage_min = core.map.cold_damage_min,
        cold_damage_max = core.map.cold_damage_max,
        lightning_damage_min = core.map.lightning_damage_min,
        lightning_damage_max = core.map.lightning_damage_max,
        chaos_damage_min = core.map.chaos_damage_min,
        chaos_damage_max = core.map.chaos_damage_max,
    },
}

core.cargo.armours = {
    table = 'armours',
    fields = {
        armour = core.map.armour,
        energy_shield = core.map.energy_shield,
        evasion = core.map.evasion,
        movement_speed = core.map.movement_speed,
    },
}

core.cargo.shields = {
    table = 'shields',
    fields = {
        block = core.map.block,
    }
}

core.cargo.skill_gems = {
    table = 'skill_gems',
    fields = {
        gem_description = core.map.gem_description,
        dexterity_percent = core.map.dexterity_percent,
        strength_percent = core.map.strength_percent,
        intelligence_percent = core.map.intelligence_percent,
        primary_attribute = core.map.primary_attribute,
        gem_tags = core.map.gem_tags,
        -- Support Skill Gems
        support_gem_letter = core.map.support_gem_letter,
        support_gem_letter_html = core.map.support_gem_letter_html,
    },
}

core.cargo.maps = {
    table = 'maps',
    fields = {
        tier = core.map.map_tier,
        guild_character = core.map.map_guild_character,
        unique_guild_character = core.map.unique_map_guild_character,
        area_id = core.map.map_area_id,
        unique_area_id = core.map.unique_map_area_id,
        series = core.map.map_series,
        
        -- REMOVE?
        area_level = core.map.map_area_level,
        unique_area_level = core.map.unique_map_area_level,
    },
}

core.cargo.atlas_maps = {
    table = 'atlas_maps',
    fields = {
        x = core.map.atlas_x,
        y = core.map.atlas_y,
        region_id = core.map.atlas_region_id,
        region_minimum = core.map.atlas_region_minimum,
        x0 = core.map.atlas_x0,
        x1 = core.map.atlas_x1,
        x2 = core.map.atlas_x2,
        x3 = core.map.atlas_x3,
        x4 = core.map.atlas_x4,
        y0 = core.map.atlas_y0,
        y1 = core.map.atlas_y1,
        y2 = core.map.atlas_y2,
        y3 = core.map.atlas_y3,
        y4 = core.map.atlas_y4,
        map_tier0 = core.map.atlas_map_tier0,
        map_tier1 = core.map.atlas_map_tier1,
        map_tier2 = core.map.atlas_map_tier2,
        map_tier3 = core.map.atlas_map_tier3,
        map_tier4 = core.map.atlas_map_tier4,
    },
}

core.cargo.atlas_connections = {
    table = 'atlas_connections',
    fields = {
        map1 = {
            field = 'map1',
            type = 'String',
        },
        map2 = {
            field = 'map2',
            type = 'String',
        },
        region0 = {
            field = 'region0',
            type = 'Boolean',
        },
        region1 = {
            field = 'region1',
            type = 'Boolean',
        },
        region2 = {
            field = 'region2',
            type = 'Boolean',
        },
        region3 = {
            field = 'region3',
            type = 'Boolean',
        },
        region4 = {
            field = 'region4',
            type = 'Boolean',
        },
    },
}

core.cargo.stackables = {
    table = 'stackables',
    fields = {
        stack_size = core.map.stack_size,
        stack_size_currency_tab = core.map.stack_size_currency_tab,
        cosmetic_type = core.map.cosmetic_type,
    },
}

core.cargo.essences = {
    table = 'essences',
    fields = {
        level_restriction = core.map.essence_level_restriction,
        level = core.map.essence_level,
        type = core.map.essence_type,
        category  = core.map.essence_category,
    },
}

core.cargo.blight_items = {
    table = 'blight_items',
    fields = {
        tier = core.map.blight_item_tier,
    },
}

core.cargo.hideout_doodads = {
    table = 'hideout_doodads',
    fields = {
        is_master_doodad = core.map.is_master_doodad,
        master = core.map.master,
        master_level_requirement = core.map.master_level_requirement,
        master_favour_cost = core.map.master_favour_cost,
        variation_count = core.map.variation_count,
    },
}

core.cargo.prophecies = {
    table = 'prophecies',
    fields = {
        prophecy_id = core.map.prophecy_id,
        prediction_text = core.map.prediction_text,
        seal_cost = core.map.seal_cost,
        objective = core.map.prophecy_objective,
        reward = core.map.prophecy_reward,
    },
}

core.cargo.divination_cards = {
    table = 'divination_cards',
    fields = {
        card_art = core.map.card_art,
    },
}

core.cargo.jewels = {
    table = 'jewels',
    fields = {
        item_limit = core.map.item_limit,
        radius_html = core.map.jewel_radius_html,
    },
}

core.cargo.incubators = {
    table = 'incubators',
    fields = {
        effect = core.map.incubator_effect,
    },
}

core.cargo.harvest_seeds = {
    table = 'harvest_seeds', 
    fields = {
        effect = core.map.seed_effect,
        type_id = core.map.seed_type_id,
        type = core.map.seed_type,
        tier = core.map.seed_tier,
        growth_cycles = core.map.seed_growth_cycles,
        required_nearby_seed_tier = core.map.seed_required_nearby_seed_tier,
        required_nearby_seed_amount = core.map.seed_required_nearby_seed_amount,
        consumed_wild_lifeforce_percentage = core.map.seed_consumed_wild_lifeforce_percentage,
        consumed_vivid_lifeforce_percentage = core.map.seed_consumed_vivid_lifeforce_percentage,
        consumed_primal_lifeforce_percentage = core.map.seed_consumed_primal_lifeforce_percentage,
        granted_craft_option_ids = core.map.seed_granted_craft_option_ids,
    },
}

core.cargo.harvest_plant_boosters = {
    table = 'harvest_plant_boosters',
    fields = {
        radius = core.map.plant_booster_radius,
        lifeforce = core.map.plant_booster_lifeforce,
        additional_crafting_options = core.map.plant_booster_additional_crafting_options,
        extra_chances = core.map.plant_booster_extra_chances,
    },
}

core.cargo.heist_equipment = {
    table = 'heist_equipment',
    fields = {
        required_job_id = core.map.heist_required_job_id,
        required_job_level = core.map.heist_required_job_level,
    },
}

core.cargo.quest_rewards = {
    table = 'quest_rewards',
    fields = {
        quest = {
            field = 'quest',
            type = 'String',
        },
        quest_id = {
            field = 'quest_id',
            type = 'String',
        },
        -- still needed?
        act = {
            field = 'act',
            type = 'Integer',
        },
        classes = {
            field = 'classes',
            type = 'List (,) of String',
        },
        class_ids = {
            field = 'class_ids',
            type = 'List (,) of String',
        },
        sockets = {
            field = 'sockets',
            type = 'Integer',
        },
        item_level = {
            field = 'item_level',
            type = 'Integer',
        },
        rarity = {
            field = 'rarity',
            type = 'String',
        },
        notes = {
            field = 'notes',
            type = 'Text',
        },
    },
}

core.cargo.vendor_rewards = {
    table = 'vendor_rewards',
    fields = {
        quest = {
            field = 'quest',
            type = 'String',
        },
        quest_id = {
            field = 'quest_id',
            type = 'String',
        },
        act = {
            field = 'act',
            type = 'Integer',
        },
        npc = {
            field = 'npc',
            type = 'String',
        },
        classes = {
            field = 'classes',
            type = 'List (,) of String',
        },
        class_ids = {
            field = 'class_ids',
            type = 'List (,) of String',
        },
    }
}

-- TODO: Second pass for i18n item classes
-- base item is default, but will be validated later
-- Notes:
--  inventory_icon must always be before alternate_art_inventory_icons 
--  drop_areas after tags
--  is_relic after rarity
core.default_args = {
    'rarity_id', 'rarity', 'name', 'name_list', 'size_x', 'size_y', 
    'drop_rarities_ids', 'drop_rarities', 'drop_enabled', 'drop_level', 'drop_level_maximum', 'drop_leagues',  'drop_text', 'required_level', 'required_level_final', 
    'inventory_icon', 'alternate_art_inventory_icons', 'flavour_text', 'flavour_text_id',
    'cannot_be_traded_or_modified', 'help_text', 'tags', 'metadata_id', 'influences', 'is_fractured', 'is_synthesised', 'is_veiled', 'is_replica', 'is_corrupted', 'is_relic', 'is_fated', 'purchase_costs', 'sell_prices_override', 'mods',
    'drop_areas', 'drop_areas_html', 'drop_monsters',
    
    'upgraded_from_disabled',
    'suppress_improper_modifiers_category',
    
    'is_prophecy', 'is_blight_item',
    
    'class',
    'is_drop_restricted',
}
-- frame_type is needed in stat_text
core.late_args = {'frame_type', 'implicit_stat_text', 'explicit_stat_text', 'stat_text'}
core.prophecy_args = {'prophecy_id', 'prediction_text', 'seal_cost', 'prophecy_objective', 'prophecy_reward'}
core.tables = {'items'}
core.class_groups = {
    flasks = {
        tables = {'flasks'},
        keys = {['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true, ['UtilityFlaskCritical'] = true},
        args = {'quality', 'flask_duration', 'charges_max', 'charges_per_use'},
    },
    weapons = {
        tables = {'weapons'},
        keys = {['Claw'] = true, ['Dagger'] = true, ['Wand'] = true, ['One Hand Sword'] = true, ['Thrusting One Hand Sword'] = true, ['One Hand Axe'] = true, ['One Hand Mace'] = true, ['Bow'] = true, ['Staff'] = true, ['Two Hand Sword'] = true, ['Two Hand Axe'] = true, ['Two Hand Mace'] = true, ['Sceptre'] = true, ['FishingRod'] = true, ['Rune Dagger'] = true, ['Warstaff'] = true},
        args = {'quality', 'required_dexterity', 'required_intelligence', 'required_strength', 'critical_strike_chance', 'attack_speed', 'physical_damage_min', 'physical_damage_max', 'lightning_damage_min', 'lightning_damage_max', 'cold_damage_min', 'cold_damage_max', 'fire_damage_min', 'fire_damage_max', 'chaos_damage_min', 'chaos_damage_max', 'weapon_range'},
        late_args = {'physical_damage_html', 'fire_damage_html', 'cold_damage_html', 'lightning_damage_html', 'chaos_damage_html', 'damage_avg', 'damage_html'},
    },
    gems = {
        tables = {'skill_gems'},
        keys = {['Active Skill Gem'] = true, ['Support Skill Gem'] = true},
        args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'primary_attribute', 'gem_tags'},
    },
    armor = {
        tables = {'armours'},
        keys = {['Gloves'] = true, ['Boots'] = true, ['Body Armour'] = true, ['Helmet'] = true, ['Shield'] = true},
        args = {'quality', 'required_dexterity', 'required_intelligence', 'required_strength', 'armour', 'energy_shield', 'evasion', 'movement_speed'},
    },
    stackable = {
        tables = {'stackables'},
        keys = {['Currency'] = true, ['StackableCurrency'] = true, ['HideoutDoodad'] = true, ['Microtransaction'] = true, ['DivinationCard'] = true, ['DelveSocketableCurrency'] = true, ['DelveStackableSocketableCurrency'] = true, ['Incubator'] = true, ['HarvestSeed'] = true, ['HarvestPlantBooster'] = true},
        args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
    },
    heist_equipment = {
        tables = {'heist_equipment'},
        keys = {['HeistEquipmentWeapon'] = true, ['HeistEquipmentTool'] = true, ['HeistEquipmentUtility'] = true, ['HeistEquipmentReward'] = true},
        args = {'heist_required_job_id', 'heist_required_job_level', 'heist_data'},
    },
}

core.class_specifics = {
    ['Amulet'] = {
        tables = {'amulets'},
        args = {'is_talisman', 'talisman_tier'},
    },
    ['LifeFlask'] = {
        args = {'flask_life'},
    },
    ['ManaFlask'] = {
        args = {'flask_mana'},
    },
    ['HybridFlask'] = {
        args = {'flask_life', 'flask_mana'},
    },
    ['UtilityFlask'] = {
        tables = {'item_buffs'},
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
    },
    ['UtilityFlaskCritical'] = {
        tables = {'item_buffs'},
        args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
    },
    ['Active Skill Gem'] = {
        defaults = {
            help_text = i18n.help_text_defaults.active_gem,
            size_x = 1,
            size_y = 1,
        },
        frame_type = 'gem',
    },
    ['Support Skill Gem'] = {
        args = {'support_gem_letter', 'support_gem_letter_html'},
        defaults = {
            help_text = i18n.help_text_defaults.support_gem,
            size_x = 1,
            size_y = 1,
        },
        frame_type = 'gem',
    },
    ['Shield'] = {
        tables = {'shields'},
        args = {'block'},
    },
    ['Map'] = {
        tables = {'maps', 'atlas_maps'},
        args = {
            'quality', 
            
            'map_tier', 
            'map_guild_character', 
            'map_area_id', 
            'map_area_level', 
            'unique_map_area_id', 
            'unique_map_area_level', 
            'unique_map_guild_character', 
            'map_series', 
            
            'atlas_x', 
            'atlas_y',
            'atlas_region_id',
            'atlas_x0',
            'atlas_x1', 
            'atlas_x2', 
            'atlas_x3', 
            'atlas_x4', 
            'atlas_y0',
            'atlas_y1', 
            'atlas_y2', 
            'atlas_y3', 
            'atlas_y4', 
            'atlas_map_tier0',
            'atlas_map_tier1',
            'atlas_map_tier2',
            'atlas_map_tier3',
            'atlas_map_tier4',
            'atlas_connections', -- pseudo to fill connections table
        },
        skip_stat_lines = i18n.stat_skip_patterns.maps,
    },
    ['Currency'] = {
        frame_type = 'currency',
    },
    ['StackableCurrency'] = {
        tables = {'essences', 'prophecies', 'blight_items'},
        args = {'is_essence', 'essence_level_restriction', 'essence_level', 'essence_type', 'essence_category', 'blight_item_tier'},
        frame_type = 'currency',
    },
    ['Microtransaction'] = {
        frame_type = 'currency',
    },
    ['HideoutDoodad'] = {
        tables = {'hideout_doodads'},
        args = {'is_master_doodad', 'master', 'master_level_requirement', 'master_favour_cost', 'variation_count'},
        frame_type = 'currency',
    },
    ['Jewel'] = {
        tables = {'jewels'},
        late_args = {'item_limit', 'jewel_radius_html'},
        defaults = {
            help_text = i18n.help_text_defaults.jewel,
        },
        skip_stat_lines = i18n.stat_skip_patterns.jewels,
    },
    ['AbyssJewel'] = {
        tables = {'jewels'},
        late_args = {'item_limit', 'jewel_radius_html'},
        skip_stat_lines = i18n.stat_skip_patterns.jewels,
    },
    ['QuestItem'] = {
        args = {'description'},
        frame_type = 'quest',
    },
    ['DivinationCard'] = {
        tables = {'divination_cards'},
        args = {'card_art',},
        frame_type = 'divicard',
    },
    ['LabyrinthItem'] = {
        frame_type = 'currency',
    },
    ['LabyrinthTrinket'] = {
        tables = {'item_buffs'},
        args = {'description', 'buff_icon'},
        frame_type = 'currency',
    },
    ['PantheonSoul'] = {
        defaults = {
            cannot_be_traded_or_modified = true,
        },
    },
    ['IncursionItem'] = {
        frame_type = 'currency',
    },
    ['Incubator'] = {
        tables = {'incubators'},
        args = {'incubator_effect'},
        frame_type = 'currency',
    },
    ['HarvestSeed'] = {
        tables = {'harvest_seeds'},
        args = {'seed_effect', 'seed_type_id', 'seed_effect', 'seed_type', 'seed_type_html', 'seed_tier', 'seed_growth_cycles', 'seed_required_nearby_seed_tier', 'seed_required_nearby_seed_amount', 'seed_consumed_wild_lifeforce_percentage', 'seed_consumed_vivid_lifeforce_percentage', 'seed_consumed_primal_lifeforce_percentage', 'seed_granted_craft_option_ids'},
        frame_type = 'currency',
    },
    ['HarvestPlantBooster'] = {
        tables = {'harvest_plant_boosters'},
        args = {'plant_booster_radius', 'plant_booster_lifeforce', 'plant_booster_additional_crafting_options', 'plant_booster_extra_chances'},
        frame_type = 'currency',
    },
}

-- add defaults from class specifics and class groups
core.item_classes = {}
core.item_classes_extend = {'tables', 'args', 'late_args'}
function core.build_item_classes(tpl_args, frame)
    core.map.class.func(tpl_args, frame)
    
    core.item_classes[tpl_args.class_id] = {
        tables = {},
        args = {},
        late_args = {},
        defaults = {},
    }
    
    for _, table_name in ipairs(core.tables) do
        table.insert(core.item_classes[tpl_args.class_id].tables, table_name)
    end
    
    for _, row in pairs(core.class_groups) do
        for class, _ in pairs(row.keys) do
            if class == tpl_args.class_id then
                for _, k in ipairs(core.item_classes_extend) do
                    if row[k] ~= nil then
                        for _, value in ipairs(row[k]) do
                            table.insert(core.item_classes[tpl_args.class_id][k], value)
                        end
                    end
                end
                break
            end
        end
    end

    local class_specifics = core.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(core.item_classes_extend) do
            if class_specifics[k] ~= nil then
                for _, value in ipairs(class_specifics[k]) do
                    table.insert(core.item_classes[tpl_args.class_id][k], value)
                end
            end
        end
        if class_specifics.defaults ~= nil then
            for key, value in pairs(class_specifics.defaults) do
                core.item_classes[tpl_args.class_id].defaults[key] = value
            end
       end
    end
end

-- GroupTable -> RowTable -> formatter function 
--
--

h.conditions = {}
h.conditions.factory = {}

function h.conditions.factory.arg (args)
    -- Required:
    --  arg: The argument to check against
    --  One must be specified
    --   value: check whether the argument equals this value
    --   values: check whether the argument is in this list of values
    --   values_assoc: check whether the argument is in this associative table
    --
    -- Optional:
    --  negate: negates the check against the value, i.e. whether the value is not equal or not in the list/table.
    if args.negate == nil then
        args.negate = false
    end
    
    -- Inner type of function depending on whether to check a single value, a list of values or an associative list of values
    local inner
    if args.value ~= nil then
        inner = function (tpl)
            return tpl == args.value
        end
    elseif args.values ~= nil then
        inner = function (tpl)
            for _, value in ipairs(args.values) do
                if tpl == value then
                    return true
                end
            end
            return false
        end
    elseif args.values_assoc ~= nil then
        inner = function(tpl) 
            return args.values_assoc[tpl] ~= nil
        end
    else
        error(string.format('Missing inner comparision function. Args: %s', mw.dumpObject(args)))
    end
    
    -- Outer type of function depending on whether to check a single value or against a table
    return function (tpl_args, frame)
        local tpl_value = tpl_args[args.arg]
        local rtr
        if type(tpl_value) == 'table' then
            rtr = false
            for key, value in pairs(tpl_value) do
                if type(key) == 'number' then
                    rtr = rtr or inner(value)
                else
                    rtr = rtr or inner(key)
                end
            end
            
         else
            rtr = inner(tpl_value)
         end
         
         if args.negate then
            rtr = not rtr
         end
         
         return rtr
     end
end

function h.conditions.factory.league (args)
    return function (tpl_args, frame)
        for _, league in ipairs(tpl_args.drop_leagues or {}) do
            if league == args.league then
                return true
            end
        end
        return false
    end
end

h.conditions.normal = h.conditions.factory.arg{arg='rarity_id', value='normal'}
h.conditions.unique = h.conditions.factory.arg{arg='rarity_id', value='unique'} 

-- Default for all entries, but can be disabled by specific ones.
core.automatic_upgraded_from_defaults = {
    is_drop_restricted = h.conditions.factory.arg{arg='is_drop_restricted', value=false},
    is_corrupted = h.conditions.factory.arg{arg='is_corrupted', value=false},
}
-- Order matters
-- Put most specific outcome at the topic and the least specific at the bottom
core.automatic_upgraded_from = {
--[[
    {
        defaults = {
            arg_key = function (tpl_args, frame) end,
        },
        condition = {
            function (tpl_args, frame) end,
        },
        text = '',
        groups = {
            {
                name = '',
                item_id = '',
                amount = 0,
                notes = '',
            },
        },
    },
    ]]
    --
    -- Item base specific
    --
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Amulets/Amulet9'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.agate_amulet))
        end,
        groups = {
            {
                -- Lysah's Respite
                item_id = "Metadata/Items/DivinationCards/DivinationCardLysahsRespite",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring15'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.unset_ring))
        end,
        groups = {
            {
                -- The Penitent
                item_id = "Metadata/Items/DivinationCards/DivinationCardThePenitent",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring4'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.gold_ring))
        end,
        groups = {
            {
                -- Glimmer of Hope
                item_id = "Metadata/Items/DivinationCards/DivinationCardGlimmerOfHope",
                amount = 8,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring8'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.prismatic_ring))
        end,
        groups = {
            {
                -- Hope
                item_id = "Metadata/Items/DivinationCards/DivinationCardHope",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='metadata_id', values={'Metadata/Items/Rings/Ring12', 'Metadata/Items/Rings/Ring13', 'Metadata/Items/Rings/Ring14'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.two_stone_ring))
        end,
        groups = {
            {
                -- Lantador's Lost Love
                item_id = "Metadata/Items/DivinationCards/DivinationCardLantadorsLostLove",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='base_item_id', values={'Metadata/Items/Rings/Ring12', 'Metadata/Items/Rings/Ring13', 'Metadata/Items/Rings/Ring14'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.two_stone_ring))
        end,
        groups = {
            {
                -- Heterochromia
                item_id = "Metadata/Items/DivinationCards/DivinationCardHeterochromia",
                amount = 2,
            },
        },
    },
    --
    -- Even more specific stuff
    -- 
    {
        defaults = {
            is_drop_restricted = false,
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='is_talisman', value=true},
            h.conditions.factory.arg{arg='talisman_tier', value=1},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.tier_1_talisman))
        end,
        groups = {
            {
                -- Call to the First Ones
                item_id = "Metadata/Items/DivinationCards/DivinationCardCallToTheFirstOnes",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return string.find(tpl_args.name, 'Atziri')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Atziri')))
        end,
        groups = {
            {
                -- The Admirer
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheAdmirer",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return string.find(tpl_args.name, 'Doedre')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Doedre')))
        end,
        groups = {
            {
                -- Doedre's Madness
                item_id = "Metadata/Items/DivinationCards/DivinationCardDoedresMadness",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return string.find(tpl_args.name, 'Shavronne')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Shavronne')))
        end,
        groups = {
            {
                -- The Aesthete
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheAesthete",
                amount = 8,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return string.find(tpl_args.name, 'Rigwald')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Rigwald')))
        end,
        groups = {
            {
                -- The Wolf
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolf",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return string.find(tpl_args.name, 'Lioneye')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Lioneye')))
        end,
        groups = {
            {
                -- The Lion
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheLion",
                amount = 5,
            },
        },
    },
    -- 
    -- League specific items
    --
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Nemesis'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Nemesis')))
        end,
        groups = {
            {
                -- The Valkyrie
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheValkyrie",
                amount = 8,
               
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Nemesis'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Nemesis')))
        end,
        groups = {
            {
                -- The Undaunted
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheUndaunted",
                amount = 5,
               
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Beyond'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Beyond')))
        end,
        groups = {
            {
                -- The Calling
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheCalling",
                amount = 6,
               
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Breach'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Breach')))
        end,
        groups = {
            {
                -- The Breach
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheBreach",
                amount = 4,
               
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Delve'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Delve')))
        end,
        groups = {
            {
                -- Alone in the Darkness
                item_id = "Metadata/Items/DivinationCards/DivinationCardAloneInTheDarkness",
                amount = 5,
               
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.league{league='Bestiary'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Bestiary')))
        end,
        groups = {
            {
                -- Boon of the First Ones
                item_id = "Metadata/Items/DivinationCards/DivinationCardBoonOfTheFirstOnes",
                amount = 6,
            },
        },
    },
    --
    -- Subset of class
    --
    {
        condition = {
            h.conditions.normal, 
            -- Seems like the other breach stones are in a different category, so this is good enough to separate from the improved stones
            h.conditions.factory.arg{arg='class_id', value='MiscMapItem'},
            function (tpl_args, frame)
                return string.find(tpl_args.metadata_id, 'BreachFragment')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.breachstone))
        end,
        groups = {
            {
                -- The Obscured
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheObscured",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
            h.conditions.factory.arg{arg='is_essence', value=true},
            h.conditions.factory.arg{arg='essence_level', value=7},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_amount, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.deafening_essence), 3)
        end,
        groups = {
            {
                -- The Cacophony
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheCacophony",
                amount = 8,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
            h.conditions.factory.arg{arg='is_essence', value=true},
            h.conditions.factory.arg{arg='essence_level', value=6},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_amount, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.shrieking_essence), 9)
        end,
        groups = {
            {
                -- Harmony of Souls
                item_id = "Metadata/Items/DivinationCards/DivinationCardHarmonyOfSouls",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
            h.conditions.factory.arg{arg='is_essence', value=true},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_amount, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.essence), 3)
        end,
        groups = {
            {
                -- Three Voices
                item_id = "Metadata/Items/DivinationCards/DivinationCardThreeVoices",
                amount = 3,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
            h.conditions.factory.arg{arg='map_tier', value=5},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 5)))
        end,
        groups = {
            {
                -- Cartographer's Delight
                item_id = "Metadata/Items/DivinationCards/DivinationCardCartographersDelight",
                amount = 3,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
            h.conditions.factory.arg{arg='map_tier', value=14},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 14)))
        end,
        groups = {
            {
                -- The Surveyor
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheSurveyor",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
            h.conditions.factory.arg{arg='map_tier', value=15},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15)))
        end,
        groups = {
            {
                -- Lost Worlds
                item_id = "Metadata/Items/DivinationCards/DivinationCardLostWorlds",
                amount = 8,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
            h.conditions.factory.arg{arg='map_tier', value=15},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15)))
        end,
        groups = {
            {
                -- The Trial
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheTrial",
                amount = 7,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
            h.conditions.factory.arg{arg='map_tier', value=16},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_unidentified_corrupted, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 16)))
        end,
        groups = {
            {
                -- Left to Fate
                item_id = "Metadata/Items/DivinationCards/DivinationCardLeftToFate",
                amount = 4,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
            h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.golem.tag},
            h.conditions.factory.arg{arg='max_level', value=20},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, 21, m_game.constants.item.gem_tags.golem.tag)))
        end,
        groups = {
            {
                -- The Rite of Elements
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheRiteOfElements",
                amount = 5,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
            h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.vaal.tag},
        },
        text = function(tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.vaal.tag, 20)))
        end,
        groups = {
            {
                -- Volatile Power
                item_id = "Metadata/Items/DivinationCards/DivinationCardVolatilePower",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='MapFragment'},
            function (tpl_args, frame)
                return string.find(tpl_args.metadata_id, 'Scarab')
            end,
            h.conditions.factory.arg{arg='tags', value='gilded_scarab'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.gilded_scarab))
        end,
        groups = {
            {
                -- More is Never Enough
                item_id = "Metadata/Items/DivinationCards/DivinationCardMoreIsNeverEnough",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='MapFragment'},
            function (tpl_args, frame)
                return string.find(tpl_args.metadata_id, 'Scarab')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.scarab))
        end,
        groups = {
            {
                -- Cameria's Cut
                item_id = "Metadata/Items/DivinationCards/DivinationCardCameriasCut",
                amount = 2,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='MapFragment'},
            function (tpl_args, frame)
                return string.find(tpl_args.metadata_id, 'Scarab')
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.scarab))
        end,
        groups = {
            {
                -- Skittering Incubator
                item_id = "Metadata/Items/Currency/CurrencyIncubationScarabs",
                amount = 1,
            },
        },
    },
    {
        defaults = {
            is_drop_restricted = false,
            is_corrupted = false,
        },
        condition = {
            h.conditions.factory.arg{arg='is_talisman', value=true},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, i18n.upgraded_from_tooltips.talisman)
        end,
        groups = {
            {
                -- Primal Incubator
                item_id = "Metadata/Items/Currency/CurrencyIncubationTalismans",
                amount = 1,
            },
        },
    },
    --
    -- One class
    --
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='UniqueFragment'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.harbinger_fragment))
        end,
        groups = {
            {
                -- The Messenger
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheMessenger",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Body Armour'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.body_armour))
        end,
        groups = {
            {
                -- The Body
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheBody",
                amount = 4,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Shield'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.shield))
        end,
        groups = {
            {
                -- The Mercenary
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheMercenary",
                amount = 5,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Claw'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Claw']))
        end,
        groups = {
            {
                -- The Wolverine
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolverine",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', values={'Dagger', 'Runedagger'}}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Dagger']))
        end,
        groups = {
            {
                -- Assassin's Favour
                item_id = "Metadata/Items/DivinationCards/DivinationCardAssassinsFavour",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', value='Sceptre'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_shaper, m_util.html.poe_color('magic', string.format('%s %s', i18n.tooltips.item_class_map['Sceptre'], frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedAttackSpeed8'}})))
        end,
        groups = {
            {
                -- The Lord of Celebration
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheLordOfCelebration",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Bow'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Bow']))
        end,
        groups = {
            {
                -- Hunter's Resolve
                item_id = "Metadata/Items/DivinationCards/DivinationCardHuntersResolve",
                amount = 8,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Jewel'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', m_game.constants.item.classes.Jewel.full))
        end,
        groups = {
            {
                -- The Garish Power
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheGarishPower",
                amount = 4,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Jewel'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', m_game.constants.item.classes.Jewel.full))
        end,
        groups = {
            {
                -- The Eye of the Dragon
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheEyeOfTheDragon",
                amount = 10,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', value='Amulet'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='IncreasedEnergyShieldPercent7'}}, i18n.upgraded_from_tooltips.amulet)))
        end,
        groups = {
            {
                -- The Sigil
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheSigil",
                amount = 3,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', value='Amulet'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.amulet))
        end,
        groups = {
            {
                -- The Warden
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWarden",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', value='Ring'},
            function (tpl_args, frame)
                return tpl_args.drop_level <= 83
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 83, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.ring, frame:expandTemplate{title='Modifier link',args={id='ChaosResist6'}})))
        end,
        groups = {
            {
                -- The Lord in Black
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheLordInBlack",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', value='Ring'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.ring))
        end,
        groups = {
            {
                -- The Opulent
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheOpulecent",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Ring'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring))
        end,
        groups = {
            {
                -- Hubris
                item_id = "Metadata/Items/DivinationCards/DivinationCardHubris",
                amount = 5,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Ring'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring))
        end,
        groups = {
            {
                -- Blind Venture
                item_id = "Metadata/Items/DivinationCards/DivinationCardBlindVenture",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Belt'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.belt))
        end,
        groups = {
            {
                -- The Wretched
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWretched",
                amount = 6,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map))
        end,
        groups = {
            {
                -- The Encroaching Darkness
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheEncroachingDarkness",
                amount = 8,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map))
        end,
        groups = {
            {
                -- Otherworldly Incubator
                item_id = "Metadata/Items/Currency/CurrencyIncubationUniqueMaps",
                amount = 8,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Wand'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Wand']))
        end,
        groups = {
            {
                -- The Traitor
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheTraitor",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Staff']))
        end,
        groups = {
            {
                -- The Tower
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheTower",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}}, 
            function (tpl_args, frame)
                return tpl_args.drop_level <= 66
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, 5, 66, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff']))
        end,
        groups = {
            {
                -- The Flora's Gift
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheFlorasGift",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}}, 
            function (tpl_args, frame)
                return tpl_args.drop_level <= 55
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, 6, 55, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff']))
        end,
        groups = {
            {
                -- The Dark Mage
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheDarkMage",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Body Armour'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, 6, 100, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour))
        end,
        groups = {
            {
                -- The Dapper Prodigy
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheDapperProdigy",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Body Armour'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_x_link, 6, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour))
        end,
        groups = {
            {
                -- The Chains that Bind
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheChainsThatBind",
                amount = 11,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'}, 
            h.conditions.factory.arg{arg='max_level', value=20},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, 20, m_game.constants.item.gem_tags.support.tag)))
        end,
        groups = {
            {
                -- Gift of the Gemling Queen
                item_id = "Metadata/Items/DivinationCards/DivinationCardGiftOfTheGemlingQueen",
                amount = 9,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.support.tag, 23)))
        end,
        groups = {
            {
                -- Dialla's Subjugation
                item_id = "Metadata/Items/DivinationCards/DivinationCardDiallasSubjugation",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Body Armour'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.body_armour))
        end,
        groups = {
            {
                -- Destined to Crumble
                item_id = "Metadata/Items/DivinationCards/DivinationCardDestinedToCrumble",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.map))
        end,
        groups = {
            {
                -- Boundless Realms
                item_id = "Metadata/Items/DivinationCards/DivinationCardBoundlessRealms",
                amount = 4,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Map'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.map))
        end,
        groups = {
            {
                -- The Explorer
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheExplorer",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', value='Gloves'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', m_game.constants.item.classes['Gloves'].full))
        end,
        groups = {
            {
                -- Mitts
                item_id = "Metadata/Items/DivinationCards/DivinationCardMitts",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='DivinationCard'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card))
        end,
        groups = {
            {
                -- The Gambler
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheGambler",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='DivinationCard'}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card))
        end,
        groups = {
            {
                -- Stacked Deck
                item_id = "Metadata/Items/DivinationCards/DivinationCardDeck",
                amount = 1,
            },
        },
    },
    --
    -- Multiple classes
    --
    {
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', values={'One Hand Axe', 'Two Hand Axe'}}, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.axe))
        end,
        groups = {
            {
                -- The Battle Born
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheBattleBorn",
                amount = 5,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
            h.conditions.factory.arg{arg='gem_tags', values_assoc=core.class_groups.gems.keys},
            h.conditions.factory.arg{arg='max_level', value=20},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, 21, m_game.constants.item.gem_tags.aura.tag)))
        end,
        groups = {
            {
                -- The Wilted Rose
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWiltedRose",
                amount = 7,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys}, 
            h.conditions.factory.arg{arg='max_level', value=20},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_gem, 20)))
        end,
        groups = {
            {
                -- The Fox
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheFox",
                amount = 6,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
            h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.minion.tag},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.minion.tag, 20)))
        end,
        groups = {
            {
                -- The Summoner
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheSummoner",
                amount = 6,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
            -- since this is checking against an array, it will check if it contains the "Spell" value
            h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.spell.tag},
            h.conditions.factory.arg{arg='max_level', value=20},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, 21, m_game.constants.item.gem_tags.spell.tag)))
        end,
        groups = {
            {
                --The Cataclysm
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheCataclysm",
                amount = 13,
            },
        },
    },
    {
        condition = {
            h.conditions.normal, 
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_gem_q_x, 20)))
        end,
        groups = {
            {
                -- Gemcutter's Promise
                item_id = "Metadata/Items/DivinationCards/DivinationCardGemcuttersPromise",
                amount = 3,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.armor.keys},
            h.conditions.factory.arg{arg='tags', value='int_armour'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedEnergyShieldPercentAndStunRecovery6'}}, i18n.upgraded_from_tooltips.armour)))
        end,
        groups = {
            {
                -- The Inoculated
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheInoculated",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.armor.keys},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.life, i18n.upgraded_from_tooltips.armour)))
        end,
        groups = {
            {
                -- The Carrion Crow
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheCarrionCrow",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_shaper_item_level_x, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery))
        end,
        groups = {
            {
                -- Perfection
                item_id = "Metadata/Items/DivinationCards/DivinationCardPerfection",
                amount = 5,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}},
            function (tpl_args, frame)
                return tpl_args.drop_level <= 79
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 79, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery))
        end,
        groups = {
            {
                -- The Lover
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheLover",
                amount = 2,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet'}},
            function (tpl_args, frame)
                return tpl_args.drop_level <= 85
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 85, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='ReduceGlobalFlatManaCostStrIntMasterVendor'}}, i18n.upgraded_from_tooltips.jewellery)))
        end,
        groups = {
            {
                -- Blessing of God
                item_id = "Metadata/Items/DivinationCards/DivinationCardBlessingOfGod",
                amount = 3,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet'}},
            function (tpl_args, frame)
                return tpl_args.drop_level <= 76
            end,
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 76, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='AddedLightningDamage9'}}, i18n.upgraded_from_tooltips.jewellery)))
        end,
        groups = {
            {
                --Struck by Lightning
                item_id = "Metadata/Items/DivinationCards/DivinationCardStruckByLightning",
                amount = 3,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Two Hand Sword', 'Two Hand Axe', 'Two Hand Mace', 'Staff', 'Bow', 'Warstaff'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.two_hand_weapon)))
        end,
        groups = {
            {
                -- Merciless Armament
                item_id = "Metadata/Items/DivinationCards/DivinationCardMercilessArmament",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Thrusting One Hand Sword', 'One Hand Sword', 'One Hand Axe', 'One Hand Mace', 'Sceptre', 'Dagger', 'Claw', 'Wand', 'Rune Dagger'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.one_hand_weapon)))
        end,
        groups = {
            {
                -- The Jester
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheJester",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values={'Sceptre', 'Dagger', 'Wand', 'Rune Dagger'}},
            h.conditions.factory.arg{arg='tags', value='attack_dagger', negate=true},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='SpellDamageOnWeapon8_'}}, i18n.upgraded_from_tooltips.one_hand_weapon)))
        end,
        groups = {
            {
                -- The Road to Power
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheRoadToPower",
                amount = 7,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique,
            h.conditions.factory.arg{arg='class_id', values={'Thrusting One Hand Sword', 'One Hand Sword', 'Two Hand Sword'}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.sword))
        end,
        groups = {
            {
                -- The Gentleman
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheGentleman",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, 100, m_util.html.poe_color('magic',string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.weapon)))
        end,
        groups = {
            {
                -- The Tyrant
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheTyrant",
                amount = 9,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.weapon, frame:expandTemplate{title='Modifier link',args={id='StrIntMasterItemGenerationCanHaveMultipleCraftedMods'}})))
        end,
        groups = {
            {
                -- The Web
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheWeb",
                amount = 8,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique,
            h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.weapon))
        end,
        groups = {
            {
                -- Atziri's Arsenal
                item_id = "Metadata/Items/DivinationCards/DivinationCardAtzirisArsenal",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.normal,
            -- specifically exclude crit flasks
            h.conditions.factory.arg{arg='class_id', values_assoc={['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true}},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='FlaskChanceRechargeOnCrit1'}}, i18n.upgraded_from_tooltips.flask)))
        end,
        groups = {
            {
                -- The Surgeon
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheSurgeon",
                amount = 4,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
            function (tpl_args, frame)
                return tpl_args.drop_leagues ~= nil and #tpl_args.drop_leagues ~= 0
            end
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.league_specific_item))
        end,
        groups = {
            {
                -- Time-Lost Relic
                item_id = "Metadata/Items/DivinationCards/DivinationCardTimeLostRelic",
                amount = 10,
            },
        },
    },
    --
    -- Generic items
    --
    {
        condition = {
            h.conditions.normal,
            -- should exclude all items that can't be rare
            h.conditions.factory.arg{arg='drop_rarities_ids', value='rare'},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_elder_item_level_x, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.item))
        end,
        groups = {
            {
                -- The Hale Heart
                item_id = "Metadata/Items/DivinationCards/DivinationCardTheHaleHeart",
                amount = 4,
            },
        },
    },
    {
        defaults = {
            is_drop_restricted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='is_fated', value=true},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('prophecy', i18n.upgraded_from_tooltips.fated_item))
        end,
        groups = {
            {
                -- Akil's Prophecy
                item_id = "Metadata/Items/DivinationCards/DivinationCardAkilsProphecy",
                amount = 3,
            },
        },
    },
    {
        defaults = {
            is_corrupted = false,
        },
        condition = {
            h.conditions.unique, 
            h.conditions.factory.arg{arg='class_id', values_assoc={['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true, ['UtilityFlaskCritical'] = true, ['Map'] = true}, negate=true},
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random_two_implicit_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.item))
        end,
        groups = {
            {
                -- Arrogance of the Vaal
                item_id = "Metadata/Items/DivinationCards/DivinationCardArroganceOfTheVaal",
                amount = 8,
            },
        },
    },
    {
        condition = {
            h.conditions.unique, 
        },
        text = function (tpl_args, frame)
            return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.item))
        end,
        groups = {
            {
                -- Jack in the Box
                item_id = "Metadata/Items/DivinationCards/DivinationCardJackInTheBox",
                amount = 4,
            },
        },
    },
    -- TODO: The void?
}

--
-- Contents here are meant to resemble the ingame infobox of items
--
core.item_display_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
    {
        -- Cosmetic item type
        {
            show = core.factory.args_present('cosmetic_type'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cosmetic_type',
                        fmt = '%s',
                        color = 'default'
                    },
                },
            },
        },
        -- Weapon type
        {
            show = function(tpl_args, frame)
                if tpl_args.class_id == nil then 
                    return false 
                end
                
                return core.class_groups.weapons.keys[tpl_args.class_id] ~= nil
            end,
            func = function(tpl_args, frame)
                local v = i18n.tooltips.item_class_map[tpl_args.class_id]
                return m_util.html.format_value(tpl_args, frame, {min=v, max=v}, {color = 'default'})
            end,
        },
        -- Hideout item type
        {
            show = function(tpl_args, frame)
                return tpl_args.class_id == 'HideoutDoodad'
            end,
            func = function(tpl_args, frame)
                return i18n.tooltips.item_class_map[tpl_args.class_id]
            end,
        },
        {
            show = core.factory.args_present('gem_tags'),
            func = function(tpl_args, frame)
                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 = core.factory.args_present('support_gem_letter_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'support_gem_letter_html',
                    },
                },
                fmt = i18n.tooltips.support_icon,
            },
        },
        {
            show = core.factory.args_present('radius'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'radius',
                        func = core.factory.descriptor_value{key='radius_description'},
                    },
                    {
                        key = 'radius_secondary',
                        func = core.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = core.factory.descriptor_value{key='radius_tertiary_description'},
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.radius,
            },
        },
        -- TODO: gem level here. Maybe put max level here?
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_cost',
                        hide_default = 100,
                        fmt = function (tpl_args, frame)
                            if tpl_args.has_percentage_mana_cost then
                                return '%i%%'
                            else
                                return '%i'
                            end
                        end,
                        inline = function (tpl_args, frame)
                            if tpl_args.has_reservation_mana_cost then
                                return i18n.tooltips.mana_reserved
                            else
                                return i18n.tooltips.mana_cost
                            end
                        end,
                    },
                    {
                        key = 'life_cost',
                        hide_default = 100,
                        fmt = '%i',
                        inline = function (tpl_args, frame)
                            return i18n.tooltips.life_cost
                        end,
                    },
                },
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_multiplier',
                        hide_default = 100,
                        fmt = '%i%%',
                    },
                },
                fmt = i18n.tooltips.mana_multiplier,
            },
        },
        -- TODO: i18n
        {
            show = true,
            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,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_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,
            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 = '%.3f sec',
                    },
                },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cooldown', 
                        hide_default = 0,
                        fmt = '%.2f sec',
                    },
                },
                fmt = i18n.tooltips.cooldown_time,
            },
        },
        {
            show = core.factory.args_present('cast_time'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cast_time',
                        hide_default = 0,
                        fmt = '%.2f sec',
                    },
                },
                fmt = i18n.tooltips.cast_time,
            },
        },
        {
            show = true,
            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,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_speed_multiplier',
                        hide_default = 100,
                        fmt = i18n.tooltips.attack_speed_multiplier_fmt,
                    },
                },
                fmt = i18n.tooltips.attack_speed_multiplier,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_effectiveness',
                        hide_default = 100,
                        fmt = '%i%%',
                    },
                },
                fmt = i18n.tooltips.damage_effectiveness,
            },
        },
        {
            show = core.factory.args_present('projectile_speed'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'projectile_speed',
                    },
                },
                fmt = i18n.tooltips.projectile_speed,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = core.factory.args_present('quality'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.quality,
            },
        },
        -- Weapon only
        {
            show = core.factory.args_present('physical_damage_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_damage_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.physical_damage,
            },       
        },
        {
            show = true, -- Elemental Damage
            func = function(tpl_args, frame)
                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 = core.factory.args_present('chaos_damage_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_damage_html',
                        fmt = '%s',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.chaos_damage,
            },       
        },
        {
            show = core.factory.args_present('critical_strike_chance_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'critical_strike_chance_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = core.factory.args_present('attack_speed_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'attack_speed_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.attacks_per_second,
            },
        },
        {
            show = core.factory.args_present('weapon_range_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'weapon_range_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.weapon_range,
            },
        },
        -- Map only
        {
            show = core.factory.args_present('map_area_level'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_area_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_level,
            },
        },
        {
            show = core.factory.args_present('map_tier'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_tier,
            },
        },
        {
            show = function(tpl_args, frame)
                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 = '%s',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function(tpl_args, frame)
                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 = '%s',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_quantity_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_quantity,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_rarity_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_rarity,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_pack_size_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.monster_pack_size,
            },
        },
        -- Jewel Only
        {
            show = true,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'item_limit',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.limited_to,
            },
        },
        {
            show = core.factory.args_present('jewel_radius_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_radius_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        -- Flask only
        {
            show = core.factory.args_present('flask_mana_html', 'flask_duration_html'),
            --func = core.factory.display_flask('flask_mana'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_mana_html',
                        fmt = '%s',
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_mana_recovery,
            },
        },
        {
            show = core.factory.args_present('flask_life_html', 'flask_duration_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_life_html',
                        fmt = '%s',
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_life_recovery,
            },
        },
        {
            -- don't display for mana/life flasks
            show = function(tpl_args, frame)
                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',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_duration,
            },
        },
        {
            show = core.factory.args_present('charges_per_use_html', 'charges_max_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'charges_per_use_html',
                        fmt = '%s',
                    },
                    {
                        key = 'charges_max_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_charges_per_use,
            },
        },
        {
            show = core.factory.args_present('buff_stat_text'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'buff_stat_text',
                        color = 'mod',
                    },
                },
            },
        },
        -- armor
        {
            show = core.factory.args_present('block_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'block_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = core.factory.args_present('armour_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = core.factory.args_present('evasion_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'evasion',
                    },
                },
                fmt = i18n.tooltips.evasion,
            },
        },
        {
            show = core.factory.args_present('energy_shield_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
        },
        {
            show = core.factory.args_present('movement_speed'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
        },
        -- Amulet only
        {
            show = core.factory.args_present('talisman_tier'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
        },
        -- Misc
        {
            show = core.factory.args_present('stack_size'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essence stuff
        {
            show = core.factory.args_present('essence_level'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
        },
        -- Blight items
        {
            show = core.factory.args_present('blight_item_tier'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Harvest seeds (upper  section)
        {
            show = core.factory.args_present('seed_tier'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = core.factory.args_present('seed_tier'),
            func = function (tpl_args, value)
                return i18n.tooltips.seed_monster
            end,
        },
        {
            show = core.factory.args_present('seed_type_html'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = core.factory.args_present('seed_growth_cycles'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Harvest plant boosters
        -- TODO: Remaining enhancements
        {
            show = core.factory.args_present('plant_booster_radius'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_radius',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        {
            show = core.factory.args_present('heist_required_npcs'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
    },
    -- Requirements
    {
        -- TODO: i18n Master name?
        {
            show = core.factory.args_present('master', 'master_level_requirement'),
            func = function(tpl_args, frame)
                -- masters have been validated before
                local data
                for i, rowdata in ipairs(m_game.constants.masters) do
                    if tpl_args.master == rowdata.full then
                        data = rowdata
                        break
                    end
                end
                
                return m_util.html.poe_color('default', i18n.tooltips.requires, string.format('[[%s|%s %s]]', data.full, data.short_upper, tpl_args.master_level_requirement))
            end
        },
        -- Instead of item level, show drop level if any
        {
            show = true, -- Requires...
            func = function(tpl_args, frame)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                        inline = i18n.tooltips.level_inline,
                        inline_color = false,
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        hide_default = 0,
                        hide_default_key = string.format('required_%s', attr),
                        inline = ', %s ' .. m_game.constants.attributes[attr].short_upper,
                        inline_color = false,
                    }
                end
                local requirements = core.factory.infobox_line{parts = parts}(tpl_args, frame)
                if requirements == nil then -- return early
                    return
                end
                requirements = string.gsub(requirements, '^, ', '')
                return string.format(i18n.tooltips.requires, requirements)
            end,
        },
        {
            show = core.factory.args_present('heist_required_job', 'heist_required_job_level'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                        fmt = '%s',
                    },
                    {
                        key = 'heist_required_job',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
        },
    },
    -- Gem description
    {
        class = 'tc -gemdesc',
        {
            show = core.factory.args_present('gem_description'),
            func = core.factory.display_raw_value('gem_description'),
        },
    },
    -- Gem Quality Stats
    {
        class = 'tc -mod',
        {
            show = core.factory.args_present('skill_quality'),
            func = function(tpl_args, frame)
                local span = mw.html.create('span')
                span
                    :addClass('quality')
                    
                local span2 = span:tag('span')
                span2
                    :addClass('quality-header')
                    :tag('span')
                        :wikitext(m_util.html.poe_color('default', i18n.tooltips.gem_quality))
                    
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span2:tag('span')
                    span_inner
                        :addClass('quality-section-select')
                        :addClass('quality-' .. i)
                        :wikitext(i)
                        :tag('span')
                            :wikitext(i18n.tooltips['gem_quality_' .. i])
                            
                    if i == 1 then
                        span_inner:addClass('quality-selected')
                    end
                end
                
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span:tag('span')
                    span_inner
                        :addClass('quality-box')
                        :addClass('quality-' .. i)
                        :wikitext(quality_data.stat_text)
                     
                     if i == 1 then
                        span_inner:addClass('quality-selected')
                     end
                end
                
                return tostring(span)
            end,
        },
    },
    -- Gem Implicit Stats
    {
        class = 'tc -mod',
        {
            show = function(tpl_args, frame)
                return core.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
            func = function(tpl_args, frame)
                lines = {}
                lines[#lines+1] = tpl_args.stat_text
                for _, tag in ipairs(tpl_args.gem_tags) do
                    if tag == 'Vaal' then
                        lines[#lines+1] = i18n.tooltips.corrupted
                        break
                    end
                end
                return table.concat(lines, '<br>')
            end,
        },
    },
    -- Implicit Stats
    {
        class = 'tc -mod',
        func = function(tpl_args, frame, container_type)
            if tpl_args.implicit_stat_text then
                return {core.display.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Stats
    {
        class = 'tc -mod',
        func = function(tpl_args, frame, container_type)
            if tpl_args.explicit_stat_text then
                return {core.display.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Experience
    --[[{
        {
            show = core.factory.args_present('experience'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = core.factory.args_present('seed_consumed_wild_lifeforce_percentage'),
            func = function (tpl_args, frame)
                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 = core.factory.args_present('seed_consumed_vivid_lifeforce_percentage'),
            func = function (tpl_args, frame)
                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 = core.factory.args_present('seed_consumed_primal_lifeforce_percentage'),
            func = function (tpl_args, frame)
                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 = core.factory.args_present('seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                        fmt = '%s',
                    },
                    {
                        key = 'seed_type_html',
                        fmt = '%s',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
        },
    },
    {
        class = 'tc -crafted',
        {
            show = core.factory.args_present('seed_effect'),
            func = core.factory.display_raw_value('seed_effect'),
        },
    },
    -- Description (currency, doodads)
    {
        class = 'tc -mod',
        {
            show = core.factory.args_present('description'),
            func = core.factory.display_raw_value('description'),
        },
        --[[{
            show = core.factory.args_present('plant_booster_additional_crafting_options'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
        },
        {
            show = core.factory.args_present('plant_booster_extra_chances'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
        },
        {
            show = core.factory.args_present('plant_booster_lifeforce'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
    },
    {
        class = 'tc -crafted',
        {
            show = core.factory.args_present('incubator_effect'),
            func = core.factory.display_raw_value('incubator_effect'),
        },
    },
    -- Variations (for doodads)
    {
        class = 'tc -mod',
        {
            show = core.factory.args_present('variation_count'),
            func = function(tpl_args, frame)
                local txt
                if tpl_args.variation_count == 1 then
                    txt = i18n.tooltips.variation_singular
                else
                    txt = i18n.tooltips.variation_plural
                end
                return string.format('%i %s', tpl_args.variation_count, txt)
            end,
        },
    },
    -- Flavour Text
    {
        class = 'tc -flavour',
        {
            show = core.factory.args_present('flavour_text'),
            func = core.factory.display_raw_value('flavour_text'),
        },
    },
    -- Prophecy text
    {
        class = 'tc -value',
        {
            show = core.factory.args_present('prediction_text'),
            func = core.factory.display_raw_value('prediction_text'),
        },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
        {
            show = core.factory.args_present('cannot_be_traded_or_modified'),
            func = function(tpl_args, frame)
                if tpl_args.cannot_be_traded_or_modified == true then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
            end,
        },
    },
    -- Help text
    {
        class = 'tc -help',
        {
            show = core.factory.args_present('help_text'),
            func = core.factory.display_raw_value('help_text'),
        },
    },
    -- Cost (i.e. vendor costs)
    {
        --class = '',
        {
            show = core.factory.args_present('master_favour_cost'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'master_favour_cost',
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.favour_cost,
            },
        },
        {
            show = core.factory.args_present('seal_cost'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = '%dx ' .. f_item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''},
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
            },
        },
    },
}

--
-- This is meant to show additional information about the item in a separate infobox
--
core.extra_display_groups = {
    {
        heading = i18n.tooltips.extra_info,
        class = '',
        {
            show = core.factory.args_present('atlas_connections'),
            func = function(tpl_args, frame)
                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
                    :attr('class', '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)
                                :attr('class', field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
                
                return tostring(tbl)
            end
        },
    },
    -- Drop info
    {
        heading = i18n.tooltips.drop_restrictions,
        class = '',
        {
            show = core.factory.args_present('drop_enabled'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                        
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.level,
            },
        },
        {
            show = core.factory.args_present('drop_leagues'),
            func = function(tpl_args, frame)
                return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
            end
        },
        {
            show = core.factory.args_present('drop_areas_html'),
            func = core.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = core.factory.args_present('drop_text'),
            func = core.factory.display_raw_value('drop_text'),
        },
        {
            show = function(tpl_args, frame)
                if tpl_args.drop_enabled == true then
                    return false
                end
                return true
            end,
            func = function(tpl_args, frame)
                local span = mw.html.create('span')
                span
                    :attr('class', 'infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
            end,
        },
    },
    {
        heading = i18n.tooltips.purchase_costs,
        {
            show = function(tpl_args, frame)
                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, frame)
                local tbl = mw.html.create('table')
                tbl
                    --:attr('class', '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,
        },
    },
    {
        heading = i18n.tooltips.sell_price,
        {
            show = core.factory.args_present('sell_price_order'),
            func = function(tpl_args, frame)
                local out = {}
                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
                
                return table.concat(out, '<br />')
            end,
        },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        -- Autoinsert here from dps map
    },
    {
        heading = i18n.tooltips.misc,
        {
            show = core.factory.args_present('class'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'class',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.item_class,
            },
        },
        {
            show = core.factory.args_present('metadata_id'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'metadata_id',
                        fmt = '%s',
                        truncate = true,
                    },
                },
                fmt = i18n.tooltips.metadata_id,
            },
        },
    },
}

for i, data in ipairs(core.dps_map) do
    table.insert(core.extra_display_groups[4], {
        show = core.factory.args_present(data.name .. '_html'),
        func = core.factory.infobox_line{
            parts = {
                {
                    key = data.name .. '_html',
                    inline = data.label_infobox .. ': %s',
                    fmt = '%s',
                    -- the html already contains the colour
                    color = false,
                },
            },
        },
    })
    if i == 5 then
        table.insert(core.extra_display_groups[4], {
            show = function (tpl_args, frame) 
                return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil
            end,
            func = function (tpl_args, frame)
                return ''
            end,
        })
    elseif i == 7 then
        table.insert(core.extra_display_groups[4], {
            show = core.factory.args_present('dps_html'),
            func = function (tpl_args, frame)
                return ''
            end,
        })
    end
end

-- ----------------------------------------------------------------------------
-- Tables
-- ----------------------------------------------------------------------------

function cargo_declare(data)
    return function(frame)
        local tpl_args = getArgs(frame, {
            parentFirst = true
        })
        frame = m_util.misc.get_frame(frame)
        
        local dcl_args = {}
        dcl_args._table = data.table
        for k, field_data in pairs(data.fields) do
            if field_data.field then
                dcl_args[field_data.field] = field_data.type
                for _, stat_data in pairs(core.stat_map) do
                    if stat_data.field == k then
                        for _, range_fields in ipairs(h.range_fields) do
                            -- if the type is nil, use the parent type
                            -- so this is set integer/float values correctly
                            dcl_args[stat_data.field .. range_fields.field] = range_fields.type or field_data.type
                        end
                        break
                    end
                end
            end
        end
        
        if dcl_args._table == 'weapons' then
            for _, dps_data in ipairs(core.dps_map) do
                for _, range_fields in ipairs(h.range_fields) do
                    -- since there is no parent, the default is float
                    dcl_args[dps_data.field .. range_fields.field] = range_fields.type or 'Float'
                end
            end
        end
        if tpl_args.debug then
            mw.logObject(dcl_args)
        end
        return m_cargo.declare(frame, dcl_args)
    end
end

p.table_items = cargo_declare(core.cargo.items)
p.table_item_sell_prices = cargo_declare(core.cargo.item_sell_prices)
p.table_item_purchase_costs = cargo_declare(core.cargo.item_purchase_costs)
p.table_item_mods = cargo_declare(core.cargo.item_mods)
p.table_item_stats = cargo_declare(core.cargo.item_stats)
p.table_item_buffs = cargo_declare(core.cargo.item_buffs)
p.table_upgraded_from_sets = cargo_declare(core.cargo.upgraded_from_sets)
p.table_upgraded_from_groups = cargo_declare(core.cargo.upgraded_from_groups)
p.table_amulets = cargo_declare(core.cargo.amulets)
p.table_flasks = cargo_declare(core.cargo.flasks)
p.table_weapons = cargo_declare(core.cargo.weapons)
p.table_armours = cargo_declare(core.cargo.armours)
p.table_shields = cargo_declare(core.cargo.shields)
p.table_skill_gems = cargo_declare(core.cargo.skill_gems)
p.table_maps = cargo_declare(core.cargo.maps)
p.table_atlas_maps = cargo_declare(core.cargo.atlas_maps)
p.table_atlas_connections = cargo_declare(core.cargo.atlas_connections)
p.table_stackables = cargo_declare(core.cargo.stackables)
p.table_essences = cargo_declare(core.cargo.essences)
p.table_blight_items = cargo_declare(core.cargo.blight_items)
p.table_hideout_doodads = cargo_declare(core.cargo.hideout_doodads)
p.table_prophecies = cargo_declare(core.cargo.prophecies)
p.table_divination_cards = cargo_declare(core.cargo.divination_cards)
p.table_jewels = cargo_declare(core.cargo.jewels)
p.table_incubators = cargo_declare(core.cargo.incubators)
p.table_harvest_seeds = cargo_declare(core.cargo.harvest_seeds)
p.table_harvest_plant_boosters = cargo_declare(core.cargo.harvest_plant_boosters)
p.table_heist_equipment = cargo_declare(core.cargo.heist_equipment)
p.table_quest_rewards = cargo_declare(core.cargo.quest_rewards)
p.table_vendor_rewards = cargo_declare(core.cargo.vendor_rewards)

-- ----------------------------------------------------------------------------
-- Page views
-- ----------------------------------------------------------------------------

--
-- Template:Item
--

function p.itembox (frame)
    --
    -- Args/Frame
    --
    local t = os.clock()
    
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    --
    -- Shared args
    --
    
    tpl_args._flags = {}
    tpl_args._base_item_args = {}
    tpl_args._mods = {}
    for _, k in ipairs({'', '_random'}) do
        for _, prefix in ipairs({'', '_implicit', '_explicit'}) do
            tpl_args[k .. prefix .. '_stats'] = {}
        end
    end
    tpl_args._subobjects = {}
    tpl_args._properties = {}
    tpl_args._errors = {}
    
    core.process_arguments(tpl_args, frame, {array={'class_id'}})
    core.build_item_classes(tpl_args, frame)
    core.build_cargo_data(tpl_args, frame)
    
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args, {frame=frame, set_properties=true})
    
    -- Must validate some argument early. It is required for future things
    core.process_arguments(tpl_args, frame, {array=core.default_args})
    core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class_id].args})
    
    -- Base Item

    core.process_base_item(tpl_args, frame)
    
    -- Prophecy special snowflake
    if tpl_args._flags.is_prophecy then
        err = core.process_arguments(tpl_args, frame, {array=core.prophecy_args})
        if err then
            return err
        end
        
        tpl_args.inventory_icon = string.format(i18n.inventory_icon, 'Prophecy')
    end
    
    -- Mods

    for _, k in ipairs({'implicit', 'explicit'}) do
        local success = true
        local i = 1
        while success do
            success = core.validate_mod(tpl_args, frame, {key=k, i=i})
            i = i + 1
        end
    end
    
    core.process_smw_mods(tpl_args, frame)
        
    -- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'})
    for _, stat in ipairs(tpl_args.extra_stats) do
        if stat.value ~= nil then
            stat.min = stat.value
            stat.max = stat.value
            stat.avg = stat.value
        end
        h.stats_update(tpl_args, stat.id, stat, nil, '_stats')
        h.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
    end

    -- Transpose stats into cargo data
    for _, random_prefix in ipairs({'', '_random'}) do
        for _, type_prefix in ipairs({'', '_implicit', '_explicit'}) do
            for id, data in pairs(tpl_args[random_prefix .. type_prefix .. '_stats']) do
                local is_implicit
                if type_prefix == '_implicit' then
                    is_implicit = true
                elseif type_prefix == '_explicit' then
                    is_implicit = false
                end
                tpl_args._subobjects[#tpl_args._subobjects+1] = {
                    _table = 'item_stats',
                    id = id,
                    min = data.min,
                    max = data.max,
                    avg = data.avg,
                    is_implicit = is_implicit,
                    is_random = random_prefix == '_random',
                }
            end
        end
    end
    
    -- Handle extra stats (for gems)
    
    if core.class_groups.gems.keys[tpl_args.class_id] then
        m_skill._skill(tpl_args, frame)
    end
    
    --
    -- Handle local stats increases/reductions/additions
    --
    
    local skip = {}
    
    -- general stats
    for k, data in pairs(core.stat_map) do
        local value = tpl_args[k]
        
        if value ~= nil and skip[k] == nil then
            value = {min=value, max=value, base=value}
            -- If stats are overriden we scan save some CPU time here
            local overridden = false
            if data.stats_override ~= nil then
                for stat_id, override_value in pairs(data.stats_override) do
                    local stat_value = tpl_args._stats[stat_id]
                    if stat_value ~= nil then
                        -- Use the value of stat
                        if override_value == true then
                            value.min = stat_value.min
                            value.max = stat_value.max
                            overridden = true
                        elseif stat_value ~= 0 then
                            value.min = override_value.min
                            value.max = override_value.max
                            overridden = true
                        end
                    end
                end
           end
                
           if overridden == false then
                -- The simple cases; this must be using ipairs as "add" must apply before
                for _, operator in ipairs({'add', 'more'}) do
                    local st = data['stats_' .. operator]
                    if st ~= nil then
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                h.stat[operator](value, tpl_args._stats[statid])
                            end
                        end
                    end
                end
                
                -- For increased stats we need to add them up first
                for stat_key, stat_func in pairs({increased=h.stat.more, increased_inverse=h.stat.more_inverse}) do
                    local st = data['stats_' .. stat_key]
                    if st ~= nil then
                        local total_increase = {min=0, max=0}
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                for var, current_value in pairs(total_increase) do
                                    total_increase[var] = current_value + tpl_args._stats[statid][var]
                                end
                            end
                        end
                        stat_func(value, total_increase)
                    end
                end
                
                if data.minimum ~= nil then
                    for _, key in ipairs({'min', 'max'}) do
                        if value[key] < data.minimum then
                            value[key] = data.minimum 
                        end
                    end
                end
            else

            end
            
            value.avg = (value.min + value.max) / 2
            
            -- don't add the properties unless we need to
            if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
                for short_key, range_data in pairs(h.range_map) do
                    tpl_args[data.field .. range_data.var] = value[short_key]
                end
                
                -- process to HTML to use on list pages or other purposes
                h.handle_range_args(tpl_args, frame, k, data.field, value, data.html_fmt_options or {})
            end
            
            for short_key, range_data in pairs(h.range_map) do
                tpl_args[k .. range_data.var] = value[short_key]
            end
        end
    end

    -- calculate and handle weapon dps
    if core.class_groups.weapons.keys[tpl_args.class_id] then
        for _, data in ipairs(core.dps_map) do
            local damage = {
                min = {},
                max = {},
            }
        
            for var_type, value in pairs(damage) do
                -- covers the min/max/avg range
                for short_key, range_data in pairs(h.range_map) do
                    value[short_key] = 0
                    for _, damage_key in ipairs(data.damage_args) do
                        value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
                    end
                end
            end

            local value = {}
            for short_key, range_data in pairs(h.range_map) do
                local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
                value[short_key] = result
                tpl_args[string.format('%s%s', data.field, range_data.var)] = result
            end
            
            if value.avg > 0 then
                h.handle_range_args(tpl_args, frame, data.name, data.field, value, data.html_fmt_options or {})
            end
        end
    end
    
    -- late processing
    core.process_arguments(tpl_args, frame, {array=core.late_args})
    core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class_id].late_args})
    
    -- Handle upgrade from restrictions/info
    core.process_upgraded_from(tpl_args, frame)
    
    
    -- Quest reward info
    core.process_quest_rewards(tpl_args, frame)
    
    -- ------------------------------------------------------------------------
    -- Infobox handling 
    -- ------------------------------------------------------------------------
    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args.html = tostring(core.display.make_main_container(tpl_args, frame, 'inline'))
    local container = core.display.make_main_container(tpl_args, frame, 'infobox')
    
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        container:wikitext(string.format('[[%s|%sx%spx]]', tpl_args.inventory_icon, c.image_size_full*tpl_args.size_x, c.image_size_full*tpl_args.size_y))
    end
    
    --
    -- Secondary infobox
    --
    
    tpl_args.extra_infobox = mw.html.create('span')
        :attr( 'class', 'item-box -' .. tpl_args.frame_type)
        
    core.display.add_to_container_from_map(tpl_args, frame, tpl_args.extra_infobox, core.extra_display_groups)
    
    -- 
    -- Output 
    --
    
    local infobox = mw.html.create('span')
    infobox
        :attr('class', 'infobox-page-container')
        :node(container)
        :node(tpl_args.extra_infobox)
        
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
    
    local out = tostring(infobox)
    tpl_args.html_extra = out
    
    -- ------------------------------------------------------------------------
    -- Category handling 
    -- ------------------------------------------------------------------------
    
    local cats = {}
    if tpl_args.rarity_id == 'unique' then
        cats[#cats+1] = string.format(i18n.categories.unique_affix, tpl_args.class)
    elseif tpl_args._flags.is_prophecy then
        cats[#cats+1] = i18n.categories.prophecies
    elseif tpl_args._flags.is_blight_item then
        cats[#cats+1] = i18n.categories.blight_item
    elseif tpl_args.is_talisman then
        cats[#cats+1] = i18n.categories.talismans
    elseif tpl_args.is_essence then
        cats[#cats+1] = i18n.categories.essences
    elseif tpl_args.class_id == 'Map' then
        cats[#cats+1] = string.format('%s %s', tpl_args.map_series, tpl_args.class)
    else
        cats[#cats+1] = tpl_args.class
    end
    
    if tpl_args.rarity_id ~= 'normal' or tpl_args.base_item == 'Prophecy' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' then
        cats[#cats+1] = i18n.categories.derived_items
    else
        cats[#cats+1] = i18n.categories.base_items
    end
    
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            cats[#cats+1] = string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class)
        end
    end
    
    local affix
    if tpl_args.class_id == 'Active Skill Gem' or tpl_args.class_id == 'Support Skill Gem' then
        affix = i18n.categories.gem_tag_affix
    end
    if affix ~= nil then
        for _, tag in ipairs(tpl_args.gem_tags) do
            cats[#cats+1] = string.format(affix, tag)
        end
    end
    
    if #tpl_args.alternate_art_inventory_icons > 0 then
        cats[#cats+1] = i18n.categories.alternate_artwork
    end
    
    -- TODO: add maintenance categories
    
    if tpl_args.release_version == nil then
        cats[#cats+1] = i18n.categories.missing_release_version
    end
    
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        cats[#cats+1] = i18n.categories.improper_modifiers
    end
    
    -- 
    for _, k in ipairs({'broken_upgraded_from_reference', 'duplicate_upgraded_from_reference', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            cats[#cats+1] = i18n.categories[k]
        end
    end
    
    out = out .. m_util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
    
    --
    --  Misc
    --
     
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    -- if tpl_args.map_series ~= i18n.misc.betrayal then
    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 .. m_area.query_area_info{cats=yes, where=string.format('areas.id="%s"', query_id)}
    end
    
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------
    -- Map argument values for cargo storage
    for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
        tpl_args._subobjects[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local data = core.map[k]
        if data ~= nil then
            if data.table ~= nil and data.field ~= nil then
                if data.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.logObject(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], data.table, data.field))
                    end
                end
                tpl_args._subobjects[data.table][data.field] = v
            elseif data.table == nil and data.field ~= nil then
                error(string.format('Missing table for field "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.field, k, mw.dumpObject(v), mw.dumpObject(data)))
            elseif data.table ~= nil and data.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.table, k, mw.dumpObject(v), mw.dumpObject(data)))
            end
        end
    end
    
    -- Don't actually save data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._subobjects) 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
                        -- Keeping this here in case it might be useful in the future.
                        -- Recreating table is very slow and doing anything while the queue is running just creates a big mess.
                        frame:expandTemplate{title=string.format('Template:Item/cargo/attach/%s', data._table), args={}}
                        break
                    end
                end
            end
            m_cargo.store(frame, 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.logObject(table.concat(tpl_args._errors, '\n'))
    end
    
    if tpl_args.test then
        tpl_args.out = out
        return tpl_args
    else
        mw.logObject(os.clock() - t)
        return out
    end
end

p.item = p.itembox


function p.query_itembox (frame)
    --[[
    Queries for an item box.
    
    Examples
    --------
    =p.query_itembox{page='Beach Map (Betrayal)'}
    ]]
    
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    local results = m_cargo.query(
        {'items', 'maps', 'areas'}, 
        {'items.html_extra', 'maps.area_id', 'areas.id', 'areas.infobox_html'},
        {
            join='items._pageID=maps._pageID, maps.area_id=areas.id',
            where=string.format('items._pageName="%s"', tpl_args.page),
        }
    )
    
    if #results == 0 then
        error('No results found')
    end
    
    local out = {
        results[1]['items.html_extra'], 
        results[1]['areas.infobox_html'],
    }
    
    return table.concat(out, '')
end

-- ----------------------------------------------------------------------------
-- Result formatting templates for SMW queries
-- ----------------------------------------------------------------------------

--
-- Template:
--

function p.simple_item_list(frame)
    -- Args
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    local query = {}
    for key, value in pairs(tpl_args) do 
        if string.sub(key, 0, 2) == 'q_' then
            query[string.sub(key, 3)] = value
        end
    end
    
    local fields = {
        'items._pageName',
        'items.name',
    }
    
    if tpl_args.no_icon == nil then
        fields[#fields+1] = 'items.inventory_icon'
    end
    
    if tpl_args.no_html == nil then
        fields[#fields+1] = 'items.html'
    end
    
    local tables = m_util.string.split(tpl_args.q_tables or '', ',%s*')
    table.insert(tables, 'items')
    
    query.groupBy = query.groupBy or 'items._pageID'
    
    local results = m_cargo.query(
        tables,
        fields,
        query
    )
    
    local out = {}
    for _, row in ipairs(results) do
        local link = f_item_link{page=row['items._pageName'], name=row['items.name'], inventory_icon=row['items.inventory_icon'] or '', html=row['items.html'] or '', skip_query=true}
        if tpl_args.format == nil then
            out[#out+1] = string.format('* %s', link)
        elseif tpl_args.format == 'none' then
            out[#out+1] = link
        elseif tpl_args.format == 'li' then
            out[#out+1] = string.format('<li>%s</li>', link)
        else
            error(string.format(i18n.errors.generic_argument_parameter, 'format', tpl_args.format))
        end
    end
    
    if tpl_args.format == nil then
        return table.concat(out, '\n')
    elseif tpl_args.format == 'none' then
        return table.concat(out, '\n')
    elseif tpl_args.format == 'li' then
        return table.concat(out)
    end
end

-- ----------------------------------------------------------------------------
-- Misc. Item templates
-- ----------------------------------------------------------------------------

-- 
-- Template:Item class
--

function p.item_class (frame)
    -- Get args
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    if not doInfoCard then
        doInfoCard = require('Module:Infocard')._main
    end
    
    local err = true
    for _, row in pairs(m_game.constants.item.classes) do
        if row['full'] == tpl_args.name then
            err = false
            break
        end
    end
    
    if err then
        error(string.format(i18n.errors.invalid_class, tostring(tpl_args.name)))
    end
    
    if tpl_args.name_list ~= nil then
        tpl_args.name_list = m_util.string.split(tpl_args.name_list, ',%s*')
    else
        tpl_args.name_list = {}
    end
    
    --
    
    local ul = mw.html.create('ul')
    for _, item in ipairs(tpl_args.name_list) do
        ul
            :tag('li')
                :wikitext(item)
                :done()
    end
    

    -- Output Infocard
    
    local tplargs = {
        ['header'] = tpl_args.name,
        ['subheader'] = i18n.item_class_infobox.page .. i18n.item_class_infobox.info,
        [1] = i18n.item_class_infobox.also_referred_to_as .. tostring(ul),
    }
    
    -- cats
    
    local cats = {
        'Item classes',
        tpl_args.name,
    }
    
    -- Done
    
    return doInfoCard(tplargs) .. m_util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
end

-- ----------------------------------------------------------------------------
-- Debug stuff
-- ----------------------------------------------------------------------------

function p.debug_print_tables (frame)
    frame = m_util.misc.get_frame(frame)
    for key, data in pairs(core.cargo) do
        mw.logObject(data.table)
    end
end

function p.debug_attach_test (frame)
    frame = m_util.misc.get_frame(frame)
    for key, data in pairs(core.cargo) do
        m_cargo.attach(frame, {_table=data.table})
    end
end

function p.debug_validate_auto_upgraded_from (frame)
    frame = m_util.misc.get_frame(frame)
    
    local q = {}
    local chk = {}
    for _, data in ipairs(core.automatic_upgraded_from) do
        for _, group in ipairs(data.groups) do
            q[#q+1] = group.item_id
            chk[group.item_id] = {
                amount=group.amount,
                text=data.text({}, frame),
            }
        end
    end
    
    local results = m_cargo.array_query{
        tables={'items', 'stackables'},
        fields={'items.name', 'items.class_id', 'items.description', 'stackables.stack_size'},
        id_field='items.metadata_id',
        id_array=q,
        query={
            join='items._pageName=stackables._pageName',
        },
    }
    
    for _, row in ipairs(results) do
        if row['items.class_id'] == 'DivinationCard' and chk[row['items.metadata_id']].amount ~= tonumber(row['stackables.stack_size']) then
            mw.logObject(string.format('Amount mismatch %s, expected %s', row['items.metadata_id'], row['stackables.stack_size']))
        end
    end
    
    tbl = mw.html.create('table')
    tbl:attr('class', 'wikitable sortable')
    for _, row in ipairs(results) do
        tbl
            :tag('tr')
                :tag('td')
                    :wikitext(row['items.name'])
                    :done()
                :tag('td')
                    :wikitext(chk[row['items.metadata_id']].text)
                    :done()
                :tag('td')
                    :wikitext(row['items.description'])
                    :done()
                :done()
    end
    
    return tostring(tbl)
end

p.h = h

-- ----------------------------------------------------------------------------
-- Return
-- ----------------------------------------------------------------------------

return p
Advertisement