#using scripts\codescripts\struct;

#using scripts\mp\_util;
#using scripts\mp\gametypes\_battlechatter;
#using scripts\mp\gametypes\_globallogic_audio;
#using scripts\mp\killstreaks\_airsupport;
#using scripts\mp\killstreaks\_helicopter;
#using scripts\mp\killstreaks\_killstreak_bundles;
#using scripts\mp\killstreaks\_killstreak_detect;
#using scripts\mp\killstreaks\_killstreak_hacking;
#using scripts\mp\killstreaks\_killstreakrules;
#using scripts\mp\killstreaks\_killstreaks;
#using scripts\mp\killstreaks\_satellite;
#using scripts\mp\teams\_teams;

#using scripts\shared\callbacks_shared;
#using scripts\shared\challenges_shared;
#using scripts\shared\clientfield_shared;
#using scripts\shared\damagefeedback_shared;
#using scripts\shared\hostmigration_shared;
#using scripts\shared\killstreaks_shared;
#using scripts\shared\math_shared;
#using scripts\shared\scoreevents_shared;
#using scripts\shared\system_shared;
#using scripts\shared\tweakables_shared;
#using scripts\shared\util_shared;
#using scripts\shared\weapons\_heatseekingmissile;
#using scripts\shared\weapons\_weaponobjects;

  
                                                                                                   	  	                                                                    	                     	                 	                                                                         	                       	                                                      	                                                      	                                                       	                                                                                                  	                                                                                                                 	                                                   	                	                                          	                                      	       	  	             	                                                     	                                                                             	                         	                                                                	                                                             	                                                             	                                                                                      	                                                         	                                                         	                                                               	                                                               	                                                   	                                                                	                                                     	                                                	                                                	                                                        	                                                                                                  	                                                                             	                                            	                                                                                    	                                          	                     	                                              	                                        	                 	   
    	   	                                                                                                                                         	                                	                                                                                                                                                                                                                                                                                                                                                                    	        	     	              	    	   	               	                                              	                                                           	                               	                     	                                                                                                           	                                                                 	                                                              	                                                                                                                                             	                            	                                     	                                       	                                                                                                              	   	                  	       	                                                    	                   	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	                                                                                                 	                                    	                                                                                        	           	                        	                                            	                                             	                                                   	                                                             	                                                         	                                                                    	                                                                                                                                                                                                                                	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	    	         	                                                              	                                                          	                                   	                                   	                                                    	                                       	                                           	     	                                                                                                                                                                                                                                                      	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         	                                                               	        	                                                                                                                              	                                                                                                                     	                               	                                                      	                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         	   	                                                                                                                                                                                                                                  	                                                                                                                                                                                                                                                                                                                                                                                                                                                   






	
#namespace counteruav;

#precache( "string", "KILLSTREAK_COUNTERUAV_INBOUND" );
#precache( "string", "KILLSTREAK_COUNTERUAV_NOT_AVAILABLE" );
#precache( "string", "KILLSTREAK_EARNED_COUNTERUAV" );
#precache( "string", "KILLSTREAK_DESTROYED_COUNTERUAV" );
#precache( "string", "KILLSTREAK_COUNTERUAV_HACKED" );
#precache( "string", "mpl_killstreak_radar" );

	
function init()
{	
	level.activeCounterUAVs = [];
	level.counter_uav_positions = GenerateRandomPoints( ( 20 ) );
	level.counter_uav_position_index = [];
	level.counter_uav_offsets = BuildOffsetList( ( 0, 0, 0 ), ( 3 ), ( 450 ), ( 450 ) );
	
	if ( level.teamBased )
	{
		foreach( team in level.teams )
		{
			level.activeCounterUAVs[ team ] = 0;
			level.counter_uav_position_index[ team ] = 0;

			level thread MovementManagerThink( team );
		}
	}
	else
	{
		level.activeCounterUAVs = [];
	}
	
	level.activePlayerCounterUAVs = [];
	
	level.counter_uav_entities = [];
			
	if( tweakables::getTweakableValue( "killstreak", "allowcounteruav" ) )
	{
		killstreaks::register( "counteruav", "counteruav", "killstreak_counteruav", "counteruav_used", &ActivateCounterUAV );
		killstreaks::register_strings( "counteruav", &"KILLSTREAK_EARNED_COUNTERUAV", &"KILLSTREAK_COUNTERUAV_NOT_AVAILABLE", &"KILLSTREAK_COUNTERUAV_INBOUND", undefined, &"KILLSTREAK_COUNTERUAV_HACKED" );
		killstreaks::register_dialog( "counteruav", "mpl_killstreak_radar", "counterUavDialogBundle", "counterUavPilotDialogBundle", "friendlyCounterUav", "enemyCounterUav", "enemyCounterUavMultiple", "friendlyCounterUavHacked", "enemyCounterUavHacked", "requestCounterUav", "threatCounterUav" );
	}

	clientfield::register( "toplayer", "counteruav", 1, 1, "int" );
	level thread WatchCounterUAVs();
	
	callback::on_connect( &OnPlayerConnect );
	callback::on_spawned( &OnPlayerSpawned );
	callback::on_joined_team( &OnPlayerJoinedTeam );
	
/#
	if ( GetDvarInt( "scr_cuav_offset_debug" ) )
		level thread WaitAndDebugDrawOffsetList();
#/

}

function OnPlayerConnect()
{
	self.entNum = self getEntityNumber();
	
	if( !level.teamBased )
	{
		level.activeCounterUAVs[ self.entNum ] = 0;
		level.counter_uav_position_index[ self.entNum ] = 0;
		self thread MovementManagerThink( self.entnum );
	}
	
	level.activePlayerCounterUAVs[ self.entNum ] = 0;
}

function OnPlayerSpawned()
{
	if( self EnemyCounterUAVActive() )
	{
		self clientfield::set_to_player( "counteruav", 1 );
	}
	else
	{
		self clientfield::set_to_player( "counteruav", 0 );
	}
}

function GenerateRandomPoints( count )
{
	points = [];
	
	for( i = 0; i < count; i++ )
	{
		point = airsupport::GetRandomMapPoint( 
		                                      (isdefined(level.cuav_map_x_offset)?level.cuav_map_x_offset:0), 
		                                      (isdefined(level.cuav_map_y_offset)?level.cuav_map_y_offset:0),
		                                      (isdefined(level.cuav_map_x_percentage)?level.cuav_map_x_percentage:( 0.50 )), 
		                                      (isdefined(level.cuav_map_y_percentage)?level.cuav_map_y_percentage:( 0.50 )) );
		
		minFlyHeight = airsupport::getMinimumFlyHeight();
		point = point + ( 0, 0, minFlyHeight + (isdefined(level.counter_uav_position_z_offset)?level.counter_uav_position_z_offset:( 1000 )) );
		points[ i ] = point;
	}
	
	return points;
}

function MovementManagerThink( teamOrEntNum )
{
	while( true )
	{
		level waittill( "counter_uav_updated" );
		
		activeCount = 0;
		
		while( level.activeCounterUAVs[ teamOrEntNum ] > 0 )
		{
			if( activeCount == 0 )
			{
				activeCount = level.activeCounterUAVs[ teamOrEntNum ];
			}
			
			currentIndex = level.counter_uav_position_index[ teamOrEntNum ];
			newIndex = currentIndex;
			
			while( newIndex == currentIndex )
			{
				newIndex = RandomIntRange( 0, ( 20 ) );	
			}
			
			destination = level.counter_uav_positions[ newIndex ];
			level.counter_uav_position_index[ teamOrEntNum ] = newIndex;
			
			level notify( "counter_uav_move_" + teamOrEntNum );
			wait( ( 5 ) + RandomIntRange( ( 5 ), ( 10 ) ) );
		}
	}
}

function GetCurrentPosition( teamOrEntNum )
{
	basePosition = level.counter_uav_positions[ level.counter_uav_position_index[ teamOrEntNum ] ];
	offset = level.counter_uav_offsets[ self.cuav_offset_index ];
	
	return basePosition + offset;
}

function AssignFirstAvailableOffsetIndex()
{
	self.cuav_offset_index = GetFirstAvailableOffsetIndex();
	
	MaintainCouterUavEntities();
}

function GetFirstAvailableOffsetIndex()
{
	// init available offset array
	available_offsets = [];
	for( i = 0; i < level.counter_uav_offsets.size; i++ )
		available_offsets[ i ] = true;
	
	// update available offsets array
	foreach( cuav in level.counter_uav_entities )
	{
		if ( isdefined( cuav ) )
		{
			available_offsets[ cuav.cuav_offset_index ] = false;
		}
	}
	
	// return first available
	for( i = 0; i < available_offsets.size; i++ )
	{
		if ( available_offsets[ i ] )
			return i;
	}
	
	/#util::warning("Max counter-uav available offset slots reached. Using slot 0 for now.");#/
	
	return 0;
}

function MaintainCouterUavEntities()
{
	for( i = level.counter_uav_entities.size; i >= 0; i-- )
	{
		if ( !isdefined( level.counter_uav_entities[ i ] ) )
	    {
			ArrayRemoveIndex( level.counter_uav_entities, i );
	    }
	}
}


/#
function WaitAndDebugDrawOffsetList()
{
	level endon( "game_ended" );

	wait 10;
	DebugDrawOffsetList();
}

function DebugDrawOffsetList()
{
	basePosition = level.counter_uav_positions[ 0 ];

	foreach ( offset in level.counter_uav_offsets )
	{
		 util::debug_sphere( basePosition + offset, 24, ( 0.95, 0.05, 0.05 ), 0.75, 9999999 ); 
	}
}
#/

function BuildOffsetList( startOffset, depth, offset_x, offset_y )
{
	offsets = [];
	for( col = 0; col < depth; col++ )
	{
		itemCount = math::pow( 2, col );
		startingIndex = ( itemCount - 1 );
		
		for( i = 0; i < itemCount; i++ )
		{
			x = offset_x * col;

			y = 0;
			if( itemCount > 1 )
			{
				y = ( i * offset_y );
				total_y = offset_y * startingIndex;
				y -= ( total_y  / 2 );
			}
			
			offsets[ startingIndex + i ] = startOffset + ( x, y, 0 );
		}
	}
	
	return offsets;
}

function ActivateCounterUAV()
{
	if( self killstreakrules::isKillstreakAllowed( "counteruav", self.team ) == false )
	{
		return false;
	}

	killstreak_id = self killstreakrules::killstreakStart( "counteruav", self.team );
	if(  killstreak_id == -1 )
	{
		return false;
	}

	counterUav = SpawnCounterUAV( self, killstreak_id );
	if( !isdefined( counterUav ) )
	{
		return false;
	}
	
	counterUAV SetScale( ( 1 ) );
	
	counterUav clientfield::set( "enemyvehicle", 1 );
	counterUav.killstreak_id = killstreak_id;
	
	counterUav thread killstreaks::WaitTillEMP( &DestroyCounterUavByEMP );
	counterUav thread killstreaks::WaitForTimeout( "counteruav", ( 30000 ), &OnTimeout, "delete", "death", "crashing" );
	counterUav thread killstreaks::WaitForTimecheck( ( ( 30000 ) / 2 ), &OnTimecheck, "delete", "death", "crashing" );
	counterUav thread util::WaitTillEndOnThreaded( "death", &DestroyCounterUav, "delete", "leaving" );
	
	counterUav SetCanDamage( true );
	counterUav thread killstreaks::MonitorDamage( "counteruav", ( 700 ), &DestroyCounterUAV, ( ( 700 ) * 0.5 ), &OnLowHealth, 0, undefined, true );
	
	counterUav PlayLoopSound( "veh_uav_engine_loop", 1 );
	
	counterUav thread ListenForMove();
	
	self killstreaks::play_killstreak_start_dialog( "counteruav", self.team, killstreak_id );
	counterUav killstreaks::play_pilot_dialog_on_owner( "arrive", "counteruav", killstreak_id );
	counterUav thread killstreaks::player_killstreak_threat_tracking( "counteruav" );
	self AddWeaponStat( GetWeapon( "counteruav" ), "used", 1 );
	
	return true;
}

function HackedPreFunction( hacker )
{
	cuav = self;
	cuav ResetActiveCounterUAV();
}

function SpawnCounterUAV( owner, killstreak_id )
{
	minFlyHeight = airsupport::getMinimumFlyHeight();
	//cuav = spawn( "script_model", airsupport::GetMapCenter() + ( 0, 0, ( minFlyHeight + COUNTER_UAV_POSITION_Z_OFFSET ) ) );
	
	cuav = SpawnVehicle( "veh_counteruav_mp", airsupport::GetMapCenter() + ( 0, 0, ( minFlyHeight + (isdefined(level.counter_uav_position_z_offset)?level.counter_uav_position_z_offset:( 1000 )) ) ), ( 0, 0, 0 ), "counteruav" );
	cuav AssignFirstAvailableOffsetIndex();
	
	cuav killstreaks::configure_team( "counteruav", killstreak_id, owner, undefined, undefined, &ConfigureTeamPost );
	cuav killstreak_hacking::enable_hacking( "counteruav", &HackedPreFunction, undefined );
		
	cuav.targetname = "counteruav";
	
	killstreak_detect::killstreakTargetSet( cuav );
	
	cuav thread heatseekingmissile::MissileTarget_ProximityDetonateIncomingMissile( "crashing", undefined, true );
	
	cuav.maxhealth = ( 700 );
	cuav.health = 99999;
	cuav.rocketDamage = ( 700 ) + 1;
	
	cuav SetDrawInfrared( true );
	
	if ( !isdefined( level.counter_uav_entities ) ) level.counter_uav_entities = []; else if ( !IsArray( level.counter_uav_entities ) ) level.counter_uav_entities = array( level.counter_uav_entities ); level.counter_uav_entities[level.counter_uav_entities.size]=cuav;;
		
	return cuav;
}


function ConfigureTeamPost( owner, isHacked )
{
	cuav = self;

	if ( isHacked == false )
	{
		cuav teams::HideToSameTeam();
	}
	else
	{
		cuav SetVisibleToAll();
	}
	cuav thread teams::WaitUntilTeamChangeSingleton( owner, "CUAV_watch_team_change", &OnTeamChange, self.entNum, "death", "leaving", "crashing" );
	cuav AddActiveCounterUAV();
}


function ListenForMove()
{
	self endon( "death" );
	self endon( "leaving" );
	
	while( true )
	{
		self thread CounterUAVMove();
		level util::waittill_any( "counter_uav_move_" + self.team, "counter_uav_move_" + self.ownerEntNum );
	}
}

function CounterUAVMove()
{
	self endon( "death" );
	self endon( "leaving" );
	level endon( "counter_uav_move_" + self.team );
	
	destination = ( 0, 0, 0 );
	
	if( level.teamBased )
	{
		destination = self GetCurrentPosition( self.team );
	}
	else
	{
		destination = self GetCurrentPosition( self.ownerEntNum );
	}
	
	lookAngles = VectorToAngles( destination - self.origin );
	rotationAccelerationDuration = ( 0.5 ) * ( 0.2 );
	rotationDecelerationDuration = ( 0.5 ) *( 0.2 );
	
	// as a vehicle, we cannot use RotateTo anymore; we'll figure this out soon
	// self RotateTo( lookAngles, COUNTER_UAV_ROTATION_DURATION, rotationAccelerationDuration, rotationDecelerationDuration );
	// self waittill( "rotatedone" );
	
	travelAccelerationDuration = ( 5 ) * ( 0.2 );
	travelDecelerationDuration = ( 5 ) * ( 0.2 );
	//self MoveTo( destination, COUNTER_UAV_SPEED, travelAccelerationDuration, travelDecelerationDuration );
	self SetVehGoalPos( destination, true, false );
}

function PlayFx( name )
{
	self endon( "death" );
	wait ( 0.1 );
	
	if ( isdefined( self ) )
	{
		PlayFXOnTag( name, self, "tag_origin" );
	}
}

function OnLowHealth( attacker, weapon )
{
	self.is_damaged = true;
	params = level.killstreakBundle["counteruav"];
	if( isdefined( params.fxLowHealth ) )
		PlayFXOnTag( params.fxLowHealth, self, "tag_origin" );
}

function OnTeamChange( entNum, event )
{
	DestroyCounterUAV( undefined, undefined );
}

function OnPlayerJoinedTeam()
{
	HideAllCounterUAVsToSameTeam();
}

function OnTimeout()
{
	self.leaving = true;
	
	self killstreaks::play_pilot_dialog_on_owner( "timeout", "counteruav" );
	
	self airsupport::Leave( ( 5 ) );
	wait( ( 5 ) );
	self RemoveActiveCounterUAV();
	Target_Remove( self );
	self delete();
}

function OnTimecheck()
{
	self killstreaks::play_pilot_dialog_on_owner( "timecheck", "counteruav", self.killstreak_id );
}

function DestroyCounterUavByEMP( attacker, arg )
{
	DestroyCounterUav( attacker, GetWeapon( "emp" ) );
}

function DestroyCounterUAV( attacker, weapon )
{
	if ( self.leaving !== true )
	{
		self killstreaks::play_destroyed_dialog_on_owner( "counteruav", self.killstreak_id );
	}
	
	attacker = self [[ level.figure_out_attacker ]]( attacker );
	if( isdefined( attacker ) && ( !isdefined( self.owner ) ||  self.owner util::IsEnemyPlayer( attacker ) ) )
	{
		challenges::destroyedAircraft( attacker, weapon, false );
		scoreevents::processScoreEvent( "destroyed_counter_uav", attacker, self.owner, weapon );
		LUINotifyEvent( &"player_callout", 2, &"KILLSTREAK_DESTROYED_COUNTERUAV", attacker.entnum );
		attacker challenges::addFlySwatterStat( weapon, self );
	}

	self PlaySound( "evt_helicopter_midair_exp" );
	self RemoveActiveCounterUAV();
	
	if ( Target_IsTarget( self ) )
	{
		Target_Remove( self );
	}

	self thread DeleteCounterUAV();
}

function DeleteCounterUAV()
{
	self notify( "crashing" );
	
	params = level.killstreakBundle["counteruav"];
	if( isdefined( params.ksExplosionFX ) && isdefined( self ) )
		self thread PlayFx( params.ksExplosionFX );
	
	wait( 0.1 );
	
	if ( isdefined( self ) )
	{
		self setModel( "tag_origin" );
	}
	
	wait( 0.2 );
	
	if ( isdefined( self ) )
	{
		self notify( "delete" );
		self delete();
	}
}

function EnemyCounterUAVActive()
{
	if( level.teamBased )
	{
		foreach( team in level.teams )
		{
			if( team == self.team )
			{
				continue;
			}
			
			if( TeamHasActiveCounterUAV( team ) )
			{
				return true;
			}
		}
	}
	else
	{
		enemies = self teams::GetEnemyPlayers();
		foreach( player in enemies )
		{
			if( player HasActiveCounterUAV() )
			{
				return true;
			}
		}
	}
	
	return false;
}


function HasActiveCounterUAV()
{
	return ( level.activeCounterUAVs[ self.entNum ] > 0 );
}

function TeamHasActiveCounterUAV( team )
{
	return ( level.activeCounterUAVs[ team ] > 0 );
}

function HasIndexActiveCounterUAV( team_or_entnum )
{
	return ( level.activeCounterUAVs[ team_or_entnum ] > 0 );
}


function AddActiveCounterUAV()
{
	if ( level.teamBased )
	{
		level.activeCounterUAVs[ self.team ]++;	
		
		foreach( team in level.teams )
		{
			if ( team == self.team )
			{
				continue;
			}
			
			if( satellite::HasSatellite( team ) )
			{
				self.owner challenges::blockedSatellite();
			}
		}
	}
	else 
	{
		level.activeCounterUAVs[ self.ownerEntnum ]++;
		
		keys = getarraykeys( level.activeCounterUAVs );
		for ( i = 0; i < keys.size; i++ )
		{
			if( keys[i] == self.ownerEntNum )
			{
				continue;
			}

			if( satellite::HasSatellite( keys[i] ) )
			{
				self.owner challenges::blockedSatellite();
				break;
			}
		}
	}
	
	level.activePlayerCounterUAVs[ self.ownerEntNum ]++;

	level notify( "counter_uav_updated" );
}

function RemoveActiveCounterUAV()
{
	cuav = self;
	cuav ResetActiveCounterUAV();
	cuav killstreakrules::killstreakStop( "counteruav", self.originalteam, self.killstreak_id );
}

function ResetActiveCounterUAV()
{
	if ( level.teamBased )
	{
		level.activeCounterUAVs[ self.team ]--;
		assert( level.activeCounterUAVs[ self.team ] >= 0 );
		if ( level.activeCounterUAVs[ self.team ] < 0 ) 
		{
			level.activeCounterUAVs[ self.team ] = 0;
		}
	}
	else if ( isdefined( self.owner ) )
	{
		assert( isdefined( self.ownerEntNum ) );
		if ( !isdefined( self.ownerEntNum ) )
		{
			self.ownerEntNum = self.owner getEntityNumber();
		}
		
		level.activeCounterUAVs[self.ownerEntNum ]--;
		
		assert( level.activeCounterUAVs[ self.ownerEntNum ] >= 0 );
		if ( level.activeCounterUAVs[ self.ownerEntNum ] < 0 ) 
		{
			level.activeCounterUAVs[ self.ownerEntNum ] = 0;
		}
	}

	level.activePlayerCounterUAVs[ self.ownerEntNum ]--;

	level notify ( "counter_uav_updated" );
}


function WatchCounterUAVs()
{
	while( true )
	{
		level waittill( "counter_uav_updated" );
		
		foreach( player in level.players )
		{
			if( player EnemyCounterUAVActive() )
			{
				player clientfield::set_to_player( "counteruav", 1 );
			}
			else
			{
				player clientfield::set_to_player( "counteruav", 0 );
			}
		}
	}
}

function HideAllCounterUAVsToSameTeam()
{
	foreach( counteruav in level.counter_uav_entities )
	{
		if ( isdefined( counteruav ) )
		{
			counteruav teams::HideToSameTeam();
			
		}
	}
}