-- API for other mods to interface with this mod


-- register an external block for use in making heatline versions and/or reinforced versions
-- if you wish to exclude one or the other, pass {heatline=true} or {reinforced=true} as 3rd argument


-- register an item that provide Repair Material to Equipment Reformer
-- value = repair material value provided by 1 item
function terumet.register_repair_material(id, value)
    -- TODO error checking
    terumet.options.repm.repair_mats[id] = value
end

-- register a tool that can be repaired in Equipment Reformer
-- needed_mat = amount of repair material value to repair fully worn tool
function terumet.register_repairable_item(id, needed_mat)
    -- TODO error checking
    terumet.options.repm.repairable[id] = needed_mat
end

-- register a new alloy smelter recipe
-- required data keys and descriptions:
local ALLOY_REQUIRED = {
    result='[itemstack string] what will be output',
    input='[table, 1-4 stacks] table of itemstacks consumed as input',
    time='[float] time in seconds to process',
    flux='[integer] amount of terumetal flux consumed from tank',
}
function terumet.register_alloy_recipe(data)
    if not data then
        error('terumet.register_alloy_recipe: no recipe data provided')
    end
    for req_key, desc in pairs(ALLOY_REQUIRED) do
        if not data[req_key] then
            error(string.format('terumet.register_alloy_recipe: recipe data is missing required key %s: %s', req_key, desc))
        end
    end
    if type(data.input) ~= 'table' or #data.input < 1 or #data.input > 4 then
        error('terumet.register_alloy_recipe: invalid input; must be a table of 1-4 itemstack strings (inclusive)')
    end
    table.insert(terumet.options.smelter.recipes, 1, data)
end

-- TODO error checking
function terumet.register_vacoven_recipe(data)
    table.insert(terumet.options.vac_oven.recipes, data)
end

-- register a new crystallized material with the provided data
-- ID of created item will be 'terumet:item_cryst_<SUFFIX>' 
-- IMPORTANT NOTE: a single source item can only be defined as a single crystal
-- for example, trying to add a new crystal for 'default:copper_lump' will override the default one
-- 
-- required data keys and descriptions:
local CRYSTAL_REQUIRED = {
    suffix='[string] ID suffix for crystallized item',
    color='[colorspec] minetest colorspec for crystallized item color',
    name='[string] name of crystallized item',
    cooking_result='[itemstack string] result of cooking crystallized item',
}


function terumet.register_crystal(data)
    local this_func = 'terumet.register_crystal'
    if not data then
        error(this_func..': no data provided')
    end
    for req_key, desc in pairs(CRYSTAL_REQUIRED) do
        if not data[req_key] then
            error(string.format('%s: data missing required key %s: %s', this_func, req_key, desc))
        end
    end
    local crys_id = terumet.id('item_cryst_'..data.suffix)
    minetest.register_craftitem( crys_id, {
        description = data.name,
        inventory_image = terumet.crystal_tex(data.color),
    })
    minetest.register_craft{ type = 'cooking',
        output = data.cooking_result,
        recipe = crys_id,
        cooktime = 5
    }
    return crys_id -- returns crystal item ID
end

-- register an item that can be put into crystal vulcanizer
-- requires source item and result, optionally include integer modifier
-- by default creates 2 result items, but count_modifier is added to that value
-- +1 more result item if vulcanizer has upgrade
function terumet.register_vulcan_result(source, result, count_modifier, specialized)
    count_modifier = count_modifier or 0
    local this_func = 'terumet.register_vulcan_result'
    if not source then error(this_func..': no source item provided') end
    if not result then error(this_func..': no result item provided') end
    local count = 2 + count_modifier
    if( count < 1 ) then count = 1 end
    terumet.options.vulcan.recipes[source] = {result, count, specialized}
end

-- register that a node can generate heat when extracted by the Environmental Entropy Extraction Heater (EEE Heater)
local ENTROPIC_REQUIRED = {
    node='[string] id of node that can be extracted',
    hu_per_s='[integer] number of heat units extracted per second',
    extract_time='[float] total amount of time to extract this node',
}
-- optional keys:
-- change_to: [string] what node this node will change into after extraction - if nil, the node will not change and thus can be extracted over and over (like air by default)
function terumet.register_entropic_node(data)
    if not data then
        error('terumet.register_entropic_node: no data provided')
    end
    for req_key, desc in pairs(ENTROPIC_REQUIRED) do
        if not data[req_key] then
            error(string.format('terumet.register_entropic_node: data is missing required key %s: %s', req_key, desc))
        end
    end
    terumet.options.heater.entropy.EFFECTS[data.node] = {hu_per_s=data.hu_per_s, extract_time=data.extract_time, change_to=data.change_to}
end


local STANDARD_INV_LISTS = {'in', 'out', 'fuel', 'upgrade'}
local EXTERNAL_MACHINES = {}
local MACHINE_REQUIRED = {
    name='[string] Name of machine',
    node_tiles='[minetest tiles definition] Tiles for machine node',
    heat_max='[integer] Base maximum heat units that can be stored by machine',
    input_slots='[integer, 0-4 expected] Size of input inventory',
    output_slots='[integer, 0-4 expected] Size of output inventory',
    has_fuel_slot='[boolean] Whether machine has direct fuel slot',
    upgrade_slots='[integer, 0-6 expected] Size of upgrade inventory',
    tick_time='[float] Time in seconds between machine ticks',
    tick_function='[fn(machine_state, dt) -> boolean] Function called when machine ticks. Return true to tick again in tick_time seconds.'
}
-- optional keys:
-- heat_provider: [boolean] true if machine generates/provides heat to adjacent machines
-- heat_transfer: [integer] Maximum amount of heat machine can send in 1 tick
-- node_name: [string] name to give machine's node. if not provided, uses same as 'name'
-- node_param2: [string] param2 to give machine's node (same as minetest's nodedef param2 setting: facedir/none/etc. )
-- custom_init: [fn(pos, meta, inv) -> nil] custom initialization for setting inventories or other metadata of a new machine
-- custom_write: [fn(machine_state)] function to call when saving machine state to metadata
-- custom_read: [fn(machine_state)] function to call when reading machine state from metadata
-- -- machine formspec options --
-- <basic>
-- machinefs_theme: [string] definition of background/listcolors for machine's formspec
-- machinefs_func: [fn(machine_state) -> string] custom function that returns formspec definition for main area above inventory in interface
-- -- <OR advanced> --
-- custom_fsdef: [fsdef table] entire customized formspec definition table for machine to use, see terumet/machine/machine.lua:build_fs for more information
--  [IMPORTANT] => using custom_fsdef completely overrides use of machinefs_* funcs and default formspec so everything must be defined

function terumet.register_heat_machine( id, data )
    if not data then
        error('terumet.register_heat_machine: no data provided')
    end
    for req_key, desc in pairs(MACHINE_REQUIRED) do
        if not data[req_key] then
            error(string.format('terumet.register_heat_machine: data is missing required key %s: %s', req_key, desc))
        end
    end

    local machine_tm_class = {
        name = data.name,
        timer = data.tick_time,
        fsdef = data.custom_fsdef or {
            control_buttons = {
                terumet.machine.buttondefs.HEAT_XFER_TOGGLE,
            },
            machine = data.machinefs_func or terumet.NO_FUNCTION,
            input = {data.input_slots > 0},
            output = {data.output_slots > 0},
            fuel_slot = {data.fuel_slot},
            theme = data.machinefs_theme,
        },
        default_heat_xfer = (data.heat_provider and terumet.machine.HEAT_XFER_MODE.PROVIDE_ONLY) or terumet.machine.HEAT_XFER_MODE.ACCEPT,
        get_drop_contents = function(machine)
            local drops = {}
            for _,std_list in ipairs(STANDARD_INV_LISTS) do
                default.get_inventory_drops(machine.pos, std_list, drops)
            end
            return drops
        end
    }

    local node_def = terumet.machine.nodedef{
        description = data.node_name or data.name,
        tiles = data.node_tiles,
        param2 = data.node_param2,
        on_construct = function(pos)
            local meta = minetest.get_meta(pos)
            local inv = meta:get_inventory()
            if data.upgrade_slots > 0 then inv:set_size('upgrade', data.upgrade_slots) end
            if data.input_slots > 0 then inv:set_size('in', data.input_slots) end
            if data.output_slots > 0 then inv:set_size('out', data.output_slots) end
            if data.has_fuel_slot then inv:set_size('fuel', 1) end
            if data.custom_init then data.custom_init(pos, meta, inv) end
            local init = {
                class = machine_tm_class,
                state = 0,
                state_time = 0,
                heat_level = 0,
                max_heat = data.heat_max,
                status_text = 'New',
                inv = inv,
                meta = meta,
                pos = pos,
            }
            terumet.machine.write_state(pos, init)
            terumet.machine.set_timer(init)
        end,
        on_timer = function(pos, dt)
            local machine = terumet.machine.tick_read_state(pos)
            local re_tick = false
            if not terumet.machine.check_overheat(machine, data.heat_max) then
                re_tick = data.tick_function(machine, dt)
                if machine.heat_xfer_mode == terumet.machine.HEAT_XFER_MODE.PROVIDE_ONLY then
                    terumet.machine.push_heat_adjacent(machine, data.heat_transfer or 50)
                end

                if data.has_fuel_slot then
                    terumet.machine.process_fuel(machine)
                    re_tick = not machine.need_heat
                end
            end
            -- write status back to meta
            terumet.machine.write_state(pos, machine)
            return re_tick
        end,
        _terumach_class = machine_tm_class
    }

    minetest.register_node( id, node_def )

    EXTERNAL_MACHINES[id] = data
end