#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\zombies\_zm_weapons;

init_weapon_upgrade()
{
    init_spawnable_weapon_upgrade();
    weapon_spawns = [];
    weapon_spawns = getentarray( "weapon_upgrade", "targetname" );

    for ( i = 0; i < weapon_spawns.size; i++ )
    {
		scripts\zm\replaced\utility::wallbuy( weapon_spawns[i].zombie_weapon_upgrade, weapon_spawns[i].target + "_weapon_upgrade", weapon_spawns[i].targetname, weapon_spawns[i].origin, weapon_spawns[i].angles, 0 );
    }
}

weapon_give( weapon, is_upgrade, magic_box, nosound )
{
	primaryweapons = self getweaponslistprimaries();
	current_weapon = self getcurrentweapon();
	current_weapon = self maps\mp\zombies\_zm_weapons::switch_from_alt_weapon( current_weapon );
	if ( !isDefined( is_upgrade ) )
	{
		is_upgrade = 0;
	}
	weapon_limit = get_player_weapon_limit( self );
	if ( is_equipment( weapon ) )
	{
		self maps\mp\zombies\_zm_equipment::equipment_give( weapon );
	}
	if ( weapon == "riotshield_zm" )
	{
		if ( isDefined( self.player_shield_reset_health ) )
		{
			self [[ self.player_shield_reset_health ]]();
		}
	}
	if ( self hasweapon( weapon ) )
	{
		if ( issubstr( weapon, "knife_ballistic_" ) )
		{
			self notify( "zmb_lost_knife" );
		}
		self givestartammo( weapon );
		if ( !is_offhand_weapon( weapon ) )
		{
			self switchtoweapon( weapon );
		}
		return;
	}
	if ( is_melee_weapon( weapon ) )
	{
		current_weapon = maps\mp\zombies\_zm_melee_weapon::change_melee_weapon( weapon, current_weapon );
	}
	else if ( is_lethal_grenade( weapon ) )
	{
		old_lethal = self get_player_lethal_grenade();
		if ( isDefined( old_lethal ) && old_lethal != "" )
		{
			self takeweapon( old_lethal );
			unacquire_weapon_toggle( old_lethal );
		}
		self set_player_lethal_grenade( weapon );
	}
	else if ( is_tactical_grenade( weapon ) )
	{
		old_tactical = self get_player_tactical_grenade();
		if ( isDefined( old_tactical ) && old_tactical != "" )
		{
			self takeweapon( old_tactical );
			unacquire_weapon_toggle( old_tactical );
		}
		self set_player_tactical_grenade( weapon );
	}
	else if ( is_placeable_mine( weapon ) )
	{
		old_mine = self get_player_placeable_mine();
		if ( isDefined( old_mine ) )
		{
			self takeweapon( old_mine );
			unacquire_weapon_toggle( old_mine );
		}
		self set_player_placeable_mine( weapon );
	}
	if ( !is_offhand_weapon( weapon ) )
	{
		self maps\mp\zombies\_zm_weapons::take_fallback_weapon();
	}
	if ( primaryweapons.size >= weapon_limit )
	{
		if ( is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) )
		{
			current_weapon = undefined;
		}
		if ( isDefined( current_weapon ) )
		{
			if ( !is_offhand_weapon( weapon ) )
			{
				if ( current_weapon == "tesla_gun_zm" )
				{
					level.player_drops_tesla_gun = 1;
				}
				if ( issubstr( current_weapon, "knife_ballistic_" ) )
				{
					self notify( "zmb_lost_knife" );
				}
				self takeweapon( current_weapon );
				unacquire_weapon_toggle( current_weapon );
			}
		}
	}
	if ( isDefined( level.zombiemode_offhand_weapon_give_override ) )
	{
		if ( self [[ level.zombiemode_offhand_weapon_give_override ]]( weapon ) )
		{
			return;
		}
	}
	if ( weapon == "cymbal_monkey_zm" )
	{
		self maps\mp\zombies\_zm_weap_cymbal_monkey::player_give_cymbal_monkey();
		self play_weapon_vo( weapon, magic_box );
		return;
	}
	else if ( issubstr( weapon, "knife_ballistic_" ) )
	{
		weapon = self maps\mp\zombies\_zm_melee_weapon::give_ballistic_knife( weapon, issubstr( weapon, "upgraded" ) );
	}
	else if ( weapon == "claymore_zm" )
	{
		self thread maps\mp\zombies\_zm_weap_claymore::claymore_setup();
		self play_weapon_vo( weapon, magic_box );
		return;
	}
	if ( isDefined( level.zombie_weapons_callbacks ) && isDefined( level.zombie_weapons_callbacks[ weapon ] ) )
	{
		self thread [[ level.zombie_weapons_callbacks[ weapon ] ]]();
		play_weapon_vo( weapon, magic_box );
		return;
	}
	if ( !is_true( nosound ) )
	{
		self play_sound_on_ent( "purchase" );
	}
	if ( is_true( magic_box ) && is_limited_weapon( weapon ) )
	{
		playsoundatposition( "mus_raygun_stinger", ( 0, 0, 0 ) );
	}
	if ( !is_weapon_upgraded( weapon ) )
	{
		self giveweapon( weapon );
	}
	else
	{
		self giveweapon( weapon, 0, self get_pack_a_punch_weapon_options( weapon ) );
	}
	acquire_weapon_toggle( weapon, self );
	self givestartammo( weapon );
	if ( !is_offhand_weapon( weapon ) )
	{
		if ( !is_melee_weapon( weapon ) )
		{
			self switchtoweapon( weapon );
		}
		else
		{
			self switchtoweapon( current_weapon );
		}
	}
	self play_weapon_vo( weapon, magic_box );

	self scripts\zm\_zm_reimagined::change_weapon_ammo(weapon);
}

ammo_give( weapon )
{
    give_ammo = 0;

    if ( !is_offhand_weapon( weapon ) )
    {
        weapon = get_weapon_with_attachments( weapon );

        if ( isdefined( weapon ) )
        {
            stockmax = weaponstartammo( weapon );
			clipmax = weaponclipsize( weapon );
            ammocount = self getammocount( weapon );

			give_ammo = ammocount < (stockmax + clipmax);

			if (!give_ammo)
			{
				alt_weap = weaponaltweaponname( weapon );

				if ( "none" != alt_weap )
				{
					stockmax = weaponstartammo( alt_weap );
					clipmax = weaponclipsize( alt_weap );
					ammocount = self getammocount( alt_weap );

					give_ammo = ammocount < (stockmax + clipmax);
				}
			}
        }
    }
    else if ( self has_weapon_or_upgrade( weapon ) )
    {
        if ( self getammocount( weapon ) < weaponmaxammo( weapon ) )
            give_ammo = 1;
    }

    if ( give_ammo )
    {
        self play_sound_on_ent( "purchase" );
        self givemaxammo( weapon );
		self setWeaponAmmoClip( weapon, weaponClipSize(weapon) );
        alt_weap = weaponaltweaponname( weapon );

        if ( "none" != alt_weap )
		{
			self givemaxammo( alt_weap );
			self setWeaponAmmoClip( alt_weap, weaponClipSize(alt_weap) );
		}

		self scripts\zm\_zm_reimagined::change_weapon_ammo(weapon);

        return true;
    }

    if ( !give_ammo )
        return false;
}

lethal_grenade_update_prompt( player )
{
	weapon = self.stub.zombie_weapon_upgrade;
	hint = level.zombie_weapons[weapon].hint;
	cost = level.zombie_weapons[weapon].cost;
	self.stub.hint_string = hint;
	self sethintstring( self.stub.hint_string, cost );
	self.stub.cursor_hint = "HINT_WEAPON";
	self.stub.cursor_hint_weapon = weapon;
	self setcursorhint( self.stub.cursor_hint, self.stub.cursor_hint_weapon );
	return 1;
}

weapon_spawn_think()
{
	cost = maps\mp\zombies\_zm_weapons::get_weapon_cost( self.zombie_weapon_upgrade );
	ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( self.zombie_weapon_upgrade );
	shared_ammo_weapon = undefined;
	second_endon = undefined;

	is_grenade = 0;
	if(weapontype( self.zombie_weapon_upgrade ) == "grenade")
	{
		is_grenade = 1;
	}

	if ( isDefined( self.stub ) )
	{
		second_endon = "kill_trigger";
		self.first_time_triggered = self.stub.first_time_triggered;
	}

	if ( isDefined( self.stub ) && is_true( self.stub.trigger_per_player ) )
	{
		self thread maps\mp\zombies\_zm_magicbox::decide_hide_show_hint( "stop_hint_logic", second_endon, self.parent_player );
	}
	else
	{
		self thread maps\mp\zombies\_zm_magicbox::decide_hide_show_hint( "stop_hint_logic", second_endon );
	}

	if ( is_grenade )
	{
		self.first_time_triggered = 0;
		hint = maps\mp\zombies\_zm_weapons::get_weapon_hint( self.zombie_weapon_upgrade );
		self sethintstring( hint, cost );
	}
	else if ( !isDefined( self.first_time_triggered ) )
	{
		self.first_time_triggered = 0;
		if ( isDefined( self.stub ) )
		{
			self.stub.first_time_triggered = 0;
		}
	}
	else if ( self.first_time_triggered )
	{
		if ( is_true( level.use_legacy_weapon_prompt_format ) )
		{
			self maps\mp\zombies\_zm_weapons::weapon_set_first_time_hint( cost, maps\mp\zombies\_zm_weapons::get_ammo_cost( self.zombie_weapon_upgrade ) );
		}
	}

	for ( ;; )
	{
		self waittill( "trigger", player );

		if ( !is_player_valid( player ) )
		{
			player thread ignore_triggers( 0.5 );
			continue;
		}

		if ( !player maps\mp\zombies\_zm_magicbox::can_buy_weapon() )
		{
			wait 0.1;
			continue;
		}

		if ( isDefined( self.stub ) && is_true( self.stub.require_look_from ) )
		{
			toplayer = player get_eye() - self.origin;
			forward = -1 * anglesToRight( self.angles );
			dot = vectordot( toplayer, forward );
			if ( dot < 0 )
			{
				continue;
			}
		}

		if ( player has_powerup_weapon() )
		{
			wait 0.1;
			continue;
		}

		player_has_weapon = player maps\mp\zombies\_zm_weapons::has_weapon_or_upgrade( self.zombie_weapon_upgrade );
		if ( !player_has_weapon && is_true( level.weapons_using_ammo_sharing ) )
		{
			shared_ammo_weapon = player maps\mp\zombies\_zm_weapons::get_shared_ammo_weapon( self.zombie_weapon_upgrade );
			if ( isDefined( shared_ammo_weapon ) )
			{
				player_has_weapon = 1;
			}
		}

		if ( is_true( level.pers_upgrade_nube ) )
		{
			player_has_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_should_we_give_raygun( player_has_weapon, player, self.zombie_weapon_upgrade );
		}

		cost = maps\mp\zombies\_zm_weapons::get_weapon_cost( self.zombie_weapon_upgrade );
		if ( player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active() )
		{
			cost = int( cost / 2 );
		}

		if ( !player_has_weapon )
		{
			if ( player.score >= cost )
			{
				if ( self.first_time_triggered == 0 )
				{
					self maps\mp\zombies\_zm_weapons::show_all_weapon_buys( player, cost, ammo_cost, is_grenade );
				}

				player maps\mp\zombies\_zm_score::minus_to_player_score( cost, 1 );
				bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, cost, self.zombie_weapon_upgrade, self.origin, "weapon" );
				level notify( "weapon_bought", player, self.zombie_weapon_upgrade );

				if ( self.zombie_weapon_upgrade == "riotshield_zm" )
				{
					player maps\mp\zombies\_zm_equipment::equipment_give( "riotshield_zm" );
					if ( isDefined( player.player_shield_reset_health ) )
					{
						player [[ player.player_shield_reset_health ]]();
					}
				}
				else if ( self.zombie_weapon_upgrade == "jetgun_zm" )
				{
					player maps\mp\zombies\_zm_equipment::equipment_give( "jetgun_zm" );
				}
				else if ( is_lethal_grenade( self.zombie_weapon_upgrade ) )
				{
					player takeweapon( player get_player_lethal_grenade() );
					player set_player_lethal_grenade( self.zombie_weapon_upgrade );
				}

				str_weapon = self.zombie_weapon_upgrade;

				if ( is_true( level.pers_upgrade_nube ) )
				{
					str_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_weapon_upgrade_check( player, str_weapon );
				}

				player maps\mp\zombies\_zm_weapons::weapon_give( str_weapon );
				player maps\mp\zombies\_zm_stats::increment_client_stat( "wallbuy_weapons_purchased" );
				player maps\mp\zombies\_zm_stats::increment_player_stat( "wallbuy_weapons_purchased" );
			}
			else
			{
				play_sound_on_ent( "no_purchase" );
				player maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "no_money_weapon" );
			}
		}
		else
		{
			str_weapon = self.zombie_weapon_upgrade;

			if ( isDefined( shared_ammo_weapon ) )
			{
				str_weapon = shared_ammo_weapon;
			}

			if ( is_true( level.pers_upgrade_nube ) )
			{
				str_weapon = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_weapon_ammo_check( player, str_weapon );
			}

			if ( is_true( self.hacked ) )
			{
				if ( !player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					ammo_cost = maps\mp\zombies\_zm_weapons::get_upgraded_ammo_cost( str_weapon );
				}
				else
				{
					ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( str_weapon );
				}
			}
			else if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
			{
				ammo_cost = maps\mp\zombies\_zm_weapons::get_upgraded_ammo_cost( str_weapon );
			}
			else
			{
				ammo_cost = maps\mp\zombies\_zm_weapons::get_ammo_cost( str_weapon );
			}

			if ( is_true( player.pers_upgrades_awarded[ "nube" ] ) )
			{
				ammo_cost = maps\mp\zombies\_zm_pers_upgrades_functions::pers_nube_override_ammo_cost( player, self.zombie_weapon_upgrade, ammo_cost );
			}

			if ( player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active() )
			{
				ammo_cost = int( ammo_cost / 2 );
			}

			if ( str_weapon == "riotshield_zm" )
			{
				play_sound_on_ent( "no_purchase" );
			}
			else if ( player.score >= ammo_cost )
			{
				if ( self.first_time_triggered == 0 )
				{
					self maps\mp\zombies\_zm_weapons::show_all_weapon_buys( player, cost, ammo_cost, is_grenade );
				}

				if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					player maps\mp\zombies\_zm_stats::increment_client_stat( "upgraded_ammo_purchased" );
					player maps\mp\zombies\_zm_stats::increment_player_stat( "upgraded_ammo_purchased" );
				}
				else
				{
					player maps\mp\zombies\_zm_stats::increment_client_stat( "ammo_purchased" );
					player maps\mp\zombies\_zm_stats::increment_player_stat( "ammo_purchased" );
				}

				if ( str_weapon == "riotshield_zm" )
				{
					if ( isDefined( player.player_shield_reset_health ) )
					{
						ammo_given = player [[ player.player_shield_reset_health ]]();
					}
					else
					{
						ammo_given = 0;
					}
				}
				else if ( player maps\mp\zombies\_zm_weapons::has_upgrade( str_weapon ) )
				{
					ammo_given = player maps\mp\zombies\_zm_weapons::ammo_give( level.zombie_weapons[ str_weapon ].upgrade_name );
				}
				else
				{
					ammo_given = player maps\mp\zombies\_zm_weapons::ammo_give( str_weapon );
				}

				if ( ammo_given )
				{
					player maps\mp\zombies\_zm_score::minus_to_player_score( ammo_cost, 1 );
					bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, ammo_cost, str_weapon, self.origin, "ammo" );
				}
			}
			else
			{
				play_sound_on_ent( "no_purchase" );

				if ( isDefined( level.custom_generic_deny_vo_func ) )
				{
					player [[ level.custom_generic_deny_vo_func ]]();
				}
				else
				{
					player maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "no_money_weapon" );
				}
			}
		}

		if ( isDefined( self.stub ) && isDefined( self.stub.prompt_and_visibility_func ) )
		{
			self [[ self.stub.prompt_and_visibility_func ]]( player );
		}
	}
}

get_upgraded_ammo_cost( weapon_name )
{
	if ( isDefined( level.zombie_weapons[ weapon_name ].upgraded_ammo_cost ) )
	{
		return level.zombie_weapons[ weapon_name ].upgraded_ammo_cost;
	}

	return 2500;
}

weapon_set_first_time_hint( cost, ammo_cost )
{
	// remove
}

makegrenadedudanddestroy()
{
	self endon( "death" );

	self notify( "grenade_dud" );
	self makegrenadedud();

	if ( isDefined( self ) )
	{
		self delete();
	}
}

createballisticknifewatcher_zm( name, weapon )
{
	watcher = self maps\mp\gametypes_zm\_weaponobjects::createuseweaponobjectwatcher( name, weapon, self.team );
	watcher.onspawn = scripts\zm\replaced\_zm_weap_ballistic_knife::on_spawn;
	watcher.onspawnretrievetriggers = maps\mp\zombies\_zm_weap_ballistic_knife::on_spawn_retrieve_trigger;
	watcher.storedifferentobject = 1;
	watcher.headicon = 0;
}