-- Utility scripts to help calculate things.

get_config = ballistics_mcm.get_config
print_dbg = ballistics_mcm.print_dbg

ini_ammo = ini_file("ammo\\importer.ltx")
ini_damage = ini_file("creatures\\damages.ltx")

ini_sounds = ini_file("ammo\\sounds.ltx")

Bone_IDs = {
	[1]  =  "bip01_pelvis", 
    [2]  =	"bip01_pelvis",
    [3]  =	"bip01_l_thigh",
    [4]  =	"bip01_l_calf",
    [5]  =	"bip01_l_foot",
	[6]  =  "bip01_l_foot", 
    [7]  =	"bip01_r_thigh",
    [8]  =	"bip01_r_calf",
    [9]  =	"bip01_r_foot",
	[10] =  "bip01_r_foot", 
    [11] =	"bip01_spine",
    [12] =	"bip01_spine1",
    [13] =	"bip01_spine2",
    -- head
    [14] =	"bip01_neck", 
    [15] =	"bip01_head",
    [16] =	"eye_left",
    [17] =	"eye_right",
    [18] =	"eyelid_1",
    [19] =	"jaw_1",
    -- endhead
	[20] = "bip01_l_clavicle", 
	[21] = "bip01_l_upperarm", 
	[22] = "bip01_l_forearm", 
	[23] = "bip01_l_hand", 
	[24] = "bip01_l_hand", 
	[25] = "bip01_l_hand", 
	[26] = "bip01_l_hand", 
	[27] = "bip01_l_hand", 
	[28] = "bip01_l_hand", 
	[29] = "bip01_l_hand", 
	[30] = "bip01_l_hand", 
	[31] = "bip01_l_hand", 
	[32] = "bip01_l_hand", 
	[33] = "bip01_r_clavicle", 
	[34] = "bip01_r_upperarm", 
	[35] = "bip01_r_forearm", 
	[36] = "bip01_r_hand", 
	[37] = "bip01_r_hand", 
	[38] = "bip01_r_hand", 
	[39] = "bip01_r_hand", 
	[40] = "bip01_r_hand", 
	[41] = "bip01_r_hand", 
	[42] = "bip01_r_hand", 
	[43] = "bip01_r_hand", 
	[44] = "bip01_r_hand", 
	[45] = "bip01_r_hand", 
	[46] = "bip01_pelvis", 
}

head_bones = {
        
    [14] =	"bip01_neck", 
    [15] =	"bip01_head",
    [16] =	"eye_left",
    [17] =	"eye_right",
    [18] =	"eyelid_1",
    [19] =	"jaw_1",
}

center_mass = {
    
	[1]  =  "bip01_pelvis", 
    [2]  =	"bip01_pelvis", 
    [11] =	"bip01_spine",
    [12] =	"bip01_spine1",
    [13] =	"bip01_spine2",
	[20] = "bip01_l_clavicle", 
	[33] = "bip01_r_clavicle",
	[46] = "bip01_pelvis", 
}


limbs = {
    [3]  = "bip01_l_thigh",
    [4]  = "bip01_l_calf",
	[6]  = "bip01_l_toe0", 
    [7]  = "bip01_r_thigh",
    [8]  = "bip01_r_calf",
	[10] = "bip01_r_toe0", 
	[22] = "bip01_l_forearm", 
	[24] = "bip01_l_finger0", 
	[25] = "bip01_l_finger01", 
	[26] = "bip01_l_finger02", 
	[27] = "bip01_l_finger1", 
	[28] = "bip01_l_finger11", 
	[29] = "bip01_l_finger12", 
	[30] = "bip01_l_finger2", 
	[31] = "bip01_l_finger21", 
	[32] = "bip01_l_finger22", 
	[35] = "bip01_r_forearm",
	[37] = "bip01_r_finger0", 
	[38] = "bip01_r_finger01", 
	[39] = "bip01_r_finger02", 
	[40] = "bip01_r_finger1", 
	[41] = "bip01_r_finger11", 
	[42] = "bip01_r_finger12", 
	[43] = "bip01_r_finger2", 
	[44] = "bip01_r_finger21", 
	[45] = "bip01_r_finger22", 
}


-- play particle at npc bone
function play_particle(npc, bone_id, name, duration)
    bone_id = (not bone_id or bone_id == 65535) and 1 or bone_id
    bone_name = Bone_IDs[bone_id] or "bip01_spine"
    duration = duration or 1
    local particle = particles_object(name)
    local bone_pos = npc:bone_position(bone_name)
    
    if particle and not particle:playing() then
        particle:play_at_pos(bone_pos)
    end
    local timeout = time_global() + (duration * 1000)
    CreateTimeEvent(npc:id(), name, 0, function(npc, bone, particle, timeout)
        if time_global() > timeout then 
            return true 
        end
        local bp = npc:bone_position(bone)
        if not particle:playing() then
            particle:play_at_pos(bp)
        end
        particle:move_to(bp, VEC_Z)
    end, npc, bone_name, particle, timeout)
end

-- play a particle at the weapon bone firepoint. good for emulating fancier muzzle fx
function play_particle_firepoint(name)
    local wpn = db.actor:active_item()
    if not wpn then return end

    last_particle = particles_object(name)
    if last_particle and not last_particle:playing() then
        local hud = utils_data.read_from_ini(nil,wpn:section(),"hud","string",nil)
        local fire_bone = utils_data.read_from_ini(nil,hud,"fire_bone","string",nil) or "wpn_body"
        local offset = utils_data.read_from_ini(nil,hud,"fire_point","string",nil) or VEC_ZERO
        offset = offset and utils_data.string_to_vector(offset)
        last_particle:play_at_pos( wpn:bone_position(fire_bone, true), offset ) 
        CreateTimeEvent("particle_stop", math.random(30), 0.7, 
        function()
            last_particle:stop()
            return true
        end)
    end
end

-- play some sounds that scale based on distance
function play_sound_on_location(snd, npc, distance)
	if not snd or not npc or not ini_sounds:section_exist(snd) then
		return
	end
    distance = distance or get_distance(db.actor, npc)
    play_sound_distance(snd, distance)
end

function play_sound_distance(snd, distance)
    to_use = distance > 10 and ini_sounds:r_string_ex(snd, "far") and "far" or "near"
    snd_to_play = ini_sounds:r_string_ex(snd, to_use)
    if not snd_to_play then return end
    snd_to_play = snd_to_play .. math.random(ini_sounds:r_float_ex(snd, to_use.."_amt") or 1)
	local s = xr_sound.get_safe_sound_object(snd_to_play)
	if s then
        -- print_dbg("Playing %s", snd_to_play)
		s:play(db.actor, 0, sound_object.s2d)
        -- snd.volume = 1
		s.volume = (distance > 10) and 0.3 + (0.7 * (1 - (clamp(distance, 2, 100) - 2)/98)) or 1
		return s
	end
end

-- pull the bone_mult from [stalker_damage] section, cache the values to prevent excessive stringsplitting
local stalker_damage = {}
function npc_bone_mult(bone_id)
    local damage_mult = stalker_damage[bone_id]
    if damage_mult then return damage_mult 
    else
        -- pull from data and cache
        local bone_name = Bone_IDs[bone_id] or "bip01_spine"
        local damages = SYS_GetParam(0, "stalker_damage", bone_name)
        damages = str_explode(damages, ",")
        stalker_damage[bone_id] = tonumber(damages[1])
        return stalker_damage[bone_id]
    end
end

-- Pull bone protection for a given NPC's bone. Can use custom bone data.
-- returns two values, second one indicates if this has already been modified
local bone_cache = {}
local custom_bone_data = {}
function npc_bone_protection(npc, bone_id)
    local id = npc:id()
    if id == AC_ID then return {
        armor = actor_bone_prot(bone_id),
        modified = false
    } end
    if custom_bone_data[id] and custom_bone_data[id][bone_id] then return {
        armor = custom_bone_data[id][bone_id],
        modified = false
    }
    else
        local bone_name = Bone_IDs[bone_id] or "bip01_spine"
        local bone_sec = read_npc_bone_sec(npc) or "stalker_hero_1"
        if not bone_cache[bone_sec] then 
            bone_cache[bone_sec] = {} 
        end
        if not bone_cache[bone_sec][bone_id] then
            local bone_armor_str = SYS_GetParam(0, bone_sec, bone_name) or "0, 0.15"
            local bone_armor = str_explode(bone_armor_str, ",") 
            bone_cache[bone_sec][bone_id] = tonumber(bone_armor[2]) or 0.15
        end
        return {
            armor = bone_cache[bone_sec][bone_id],
            modified = false
        }
    end
end

function hit_frac(npc, bone_id)
    local bone_sec = read_npc_bone_sec(npc) or "stalker_hero_1"
    return SYS_GetParam(2, bone_sec, "hit_fraction_npc") or 0.5
end

-- compute actor bone prot based on active suit
function actor_bone_prot(bone_id)
    local helmet = db.actor:item_in_slot(12)
    if head_bones[bone_id] and helmet then
        return helmet:cast_Helmet():GetBoneArmor(bone_id)
    else
        local outfit = db.actor:item_in_slot(7)
        if not outfit then return 0 
        else return outfit:cast_CustomOutfit():GetBoneArmor(bone_id) end
    end
end

function read_npc_bone_sec(npc)
    local visual_data = game.get_visual_userdata(npc:get_visual_name())
    if not visual_data then
        printf("!!! Visual %s is lacking data !!!", npc:get_visual_name())
        return "stalker_hero_1"
    end
    local bone_sec = visual_data:r_string_ex("bone_protection", "bones_protection_sect", "stalker_hero_1") 
    visual_data:close()
    return bone_sec
end

-- Used to modify the custom values of a stalker's bone armors (to account for reductions, etc)
function modify_bone(npc, bone_id, new_val)
    local npc_id = npc:id()
    if npc_id == AC_ID then return end
    if not custom_bone_data[npc_id] then custom_bone_data[npc_id] = {} end
    custom_bone_data[npc_id][bone_id] = new_val
end

-- util to collect information about a bone - damage multiplier, id, name
function npc_bone_data(npc, bone_id)
    bone_prot = npc_bone_protection(npc, bone_id)
    local data = {
        id = bone_id,
        name = Bone_IDs[bone_id],
        armor = bone_prot.armor,
        modified = bone_prot.modified,
        mult = npc_bone_mult(bone_id),
        hit_fraction = hit_frac(npc, bone_id)
    }
    -- halve leg armor and damage multiplier
    if get_config("legs") and limbs[bone_id] then
        data.armor = data.armor / 2
        data.mult = data.mult / 2
    end
    return data
end

function npc_on_death_callback(npc, who)
    if custom_bone_data[npc:id()] then
        custom_bone_data[npc:id()] = nil
    end
end

-- zombies have an inexplicable 0.1x damage multiplier that isn't reflected anywhere, so I added it here
local undead_clsid = {
    SM_IZLOM 				= true,
    SM_ZOMBI 				= true
}

local mutant_hp = {
    SM_BLOOD 			= 1.5,
    SM_CONTR 			= 3,
    SM_CHIMS 			= 3,
    SM_IZLOM 			= 10,
    SM_ZOMBI			= 10,
}

local burer = {
    SM_BURER            = 3
}
function mutant_prot_values(mutant, id)
    
    local sec = mutant:section()
    local skin_armor = SYS_GetParam(2, sec, "skin_armor")
    local clsid = SYS_GetParam(0, sec, "kind")
    if not clsid or clsid == "" then clsid = SYS_GetParam(0, sec, "class") or "" end 
    local prot_sec = SYS_GetParam(0, sec, "protections_sect")
    local burer_lv = get_config("burer") or 0
    if not skin_armor then
        if prot_sec then
            skin_armor = SYS_GetParam(2, prot_sec, "skin_armor") or 0
        else skin_armor = 0 end
    end
    local hit_frac = SYS_GetParam(2, sec, "hit_fraction_monster") 
    if not hit_frac and prot_sec then
        hit_frac = SYS_GetParam(2, prot_sec, "hit_fraction_monster")
    end
    if not hit_frac then hit_frac = 0.5 end
    local mult = mutant_hp[clsid] and (get_config("mutant") or undead_clsid[clsid]) and 1/mutant_hp[clsid] or 1
    
    local snork = get_config("snork")
    if snork > 0 and clsid == SM_SNORK then
        skin_armor = skin_armor / (snork * 2)
        mult = mult * (1 + snork)
    end

    if burer[clsid] then
        if burer_lv > 0 then
            skin_armor = skin_armor / 2
        end
        if burer_lv == 1 then
            mult = 0.4
        end
    end
    return {
        id = id,
        hit_fraction = hit_frac,
        armor = skin_armor,
        deflect = (burer[clsid] and burer_lv == 2) and true or false,
        mult = mult
    }
end

-- Utils to handle storing velocity. Before weapon fired, compute and cache velocity modifier
local cur_wep_data = {
    id = 0
}
-- check and update current weapon to cache hit power, velocity and recoil (for recoil module)
function actor_on_weapon_before_fire(flags)
    local current_wpn = db.actor:active_item()
    if not current_wpn then return end
    -- cache
    local id = current_wpn:id()
    local sec = current_wpn:section()
    if not cur_wep_data.id or cur_wep_data.id ~= id then
        if IsWeapon(current_wpn) and not IsItem("fake_ammo_wpn",sec) then
            cur_wep_data.id = current_wpn:id()
            base_vel = SYS_GetParam(2, sec, "bullet_speed")
            base_degrade = SYS_GetParam(2, sec, "condition_shot_dec") or 0
            base_recoil = SYS_GetParam(2, sec, "cam_step_angle_horz")
            local vel_add = 0
            local recoil_add = 0
            local upgrades = utils_item.get_upgrades_installed(current_wpn)
            for _, upgrade in pairs(upgrades) do
                local section = ini_sys:r_string_ex(upgrade, "section")
                local speed_adj = ini_sys:r_string_ex(section,"bullet_speed")
                if speed_adj then
                    local op = string.sub(speed_adj, 1, 1)
                    local val = tonumber(string.sub(speed_adj, 2))
        
                    vel_add = op == "+" and vel_add + val or vel_add - val
                end

                local shot_dec = ini_sys:r_string_ex(section,"condition_shot_dec")
				if shot_dec then
					local op = string.sub(shot_dec, 1, 1)
					local val = tonumber(string.sub(shot_dec, 2))
					base_degrade = op == "+" and base_degrade + val or base_degrade - val
				end
            end
            cur_wep_data.vel_mod = vel_add/base_vel
            cur_wep_data.dec = base_degrade
            -- print_dbg("Stored velocity mod %s, recoil %s, degradation %s for wpn %s", cur_wep_data.vel_mod, cur_wep_data.recoil, base_degrade, sec)
        else
            -- clear
            -- print_dbg("Clearing cwd")
            cur_wep_data.id = 0
            cur_wep_data.vel_mod = 0
            cur_wep_data.dec = 0
        end
    end
end

-- return the velocity modifier for the current weapon, or 1
function get_cur_vel()
    return cur_wep_data.vel_mod or 1
end

function get_recoil()
    return cur_wep_data.recoil or 1
end

-- Provide a damage modifier based on distance, adjusted by bullet velocity and flatness
function modify_distance(shooter, npc, ammo)
	local dist = get_distance(shooter, npc)
    local air_res = SYS_GetParam(2, ammo, "k_air_resistance") or 0.05
    air_res = clamp(air_res, 0, 1.1)
    local mod = clamp( 1 / ( 1 + (dist / 600) * air_res / ( 1.3 - air_res)), 0.02, 1)
    -- print_dbg("applying distance modifier %s", mod)
    return mod
end

function get_distance(shooter, npc)
    local npc_pos = npc:position()
	local shooter_pos = shooter:position()
	return npc_pos:distance_to(shooter_pos)
end

-- One way to modify damage based on velocity. 20% of bonus velocity (e.g. taken from flatness upgrades) is added as hit damage.
-- Of course, you don't need to use this
function modify_velocity()
    -- 20% of velocity bonus becomes damage
    local velocity_mod = (1 + (get_cur_vel() / 5))
    -- print_dbg("Applying velocity damage multiplier of %s", velocity_mod)
    return velocity_mod
end

-- Modify weapon degradation based on ammo type to be correct, if needed. Leverage stored data
-- eg. if ammo degrade in custom config is 1.5 and is 1 in weapon_ammo, reduce weapon dura by 0.5 x condition_shot_dec
function actor_on_weapon_fired(obj, weapon, ammo_elapsed, grenade_elapsed, ammo_type, grenade_type)
    if weapon:id() ~= cur_wep_data.id then return end
    if not get_config("impair") then return end
    local sec = weapon:section()
    ammo_map = utils_item.get_ammo(nil, cur_wep_data.id)
    local ammo = ammo_map[weapon:get_ammo_type() + 1]
    local base_degrade = SYS_GetParam(2, ammo, "impair")
    local actual_degrade = ini_ammo:r_float_ex(ammo, "impair") or base_degrade
    if base_degrade == actual_degrade then return end
    local diff = (actual_degrade - base_degrade) * cur_wep_data.dec
    -- print_dbg("Adjusting weapon cond by %s", diff)
    weapon:set_condition(clamp(weapon:condition() - diff, 0.001, 0.999))
end


function on_get_item_cost(kind, obj, profile, calculated_cost, ret)
	if not (obj and profile) then
		return nil
	end

    if not get_config("cost") then return end

	local sec = obj:section()
	local discount = profile.discount

	local ammo = IsItem("ammo",sec)
	if ammo and ini_ammo:section_exist(sec) and ini_ammo:r_float_ex(sec, "cost") then
        ret.new_cost = ini_ammo:r_float_ex(sec, "cost") * discount * (obj:ammo_get_count() / ammo)
	end
end

function on_game_start()
    RegisterScriptCallback("actor_on_weapon_before_fire", actor_on_weapon_before_fire)
    RegisterScriptCallback("actor_on_weapon_fired", actor_on_weapon_fired)
    RegisterScriptCallback("on_get_item_cost", on_get_item_cost)
	RegisterScriptCallback("npc_on_death_callback",npc_on_death_callback)
	RegisterScriptCallback("monster_on_hit_callback",npc_on_death_callback)
end