#define DROP_DIST '0 0 32768'

void G_Jotun_DropItem( float requestId, entity item, vector targetPos ) {
	if ( sys.isClient() ) {
		return;
	}

	sys.waitFrame();
		
	vector dropOrigin = item.getWorldOrigin();
	dropOrigin_x = targetPos_x;
	dropOrigin_y = targetPos_y;

	entity parachute;	
	
	vector down	= dropOrigin - DROP_DIST;
	float frac;
	if ( item.vDropItemTrace( dropOrigin, down, item, targetPos ) ) {
		if ( !item.vAllowDrop() ) {
			if ( requestId != -1 ) {
				sys.clearDeployRequest( requestId );
				requestId = -1;
			}
			item.remove();
			return;
		}
		frac = sys.getTraceFraction();
	} else {
		frac = sys.tracePoint( dropOrigin, down, CONTENTS_SOLID | CONTENTS_MOVEABLECLIP, item );
	}

	if ( frac == 1.f ) {
		sys.warning( "G_Jotun_DropItem did not find the ground" );
	}

	vector finalDestinationII = sys.getTraceEndPos();
	item.setComeToRest( false );
	item.setGroundPosition( finalDestinationII );
	item.disableKnockback();

	entity traceEnt = sys.getTraceEntity();
	if ( traceEnt != $null_entity && traceEnt != sys.getEntity( "worldspawn" ) ) {
		item.vBindToEntity( traceEnt );
	}
	
	float parachuteDelay = item.getFloatKeyWithDefault( "parachute_deploy_delay", 3.f );
	
	float parachuteTime = sys.getTime() + parachuteDelay;
	float parachuteZ = finalDestinationII_z + 4196;

	while( 1 ) {
		sys.waitFrame();

		if ( item == $null_entity ) { // Gordon: map restart may have happened, or something else that removes the entity, don't want to spin forever
			return;
		}
		
		vector origin = item.getWorldOrigin();
		vector velocity = item.getLinearVelocity();
		vector delta = origin - finalDestinationII;
		
		if ( parachuteTime != -1 && sys.getTime() > parachuteTime && origin_z < parachuteZ ) {
			// spawn a parachute on the dropped vehicle
			string paraDef = item.getKeyWithDefault( "def_parachute", "round_parachute" );
			
			if ( paraDef != "" ) {
				parachute = sys.spawn( paraDef );
				if ( parachute != $null_entity ) {
					parachute.vSetOwner( item );
					parachute.vForceStayOpen( true );
				}
			}
			
			parachuteTime = -1;		

			if ( item.vSkipDeployDrop() ) {
				break;
			}
		}

		float count = item.entitiesInBounds( item.getAbsMins(), item.getAbsMaxs(), -1, 0 );
		float index;
		for ( index = 0; index < count; index++ ) {
			entity other = item.getBoundsCacheEntity( index );
			other.applyDamage( $null_entity, item, down, GetDamage( "damage_magog_npc_collide" ), 1.f, $null_entity ); // FIXME: Get damage decl
		}
		
		if ( delta_z <= 1 ) {
			break;
		}

		if ( velocity_z != 0.f ) {
			// drift the item towards its destination to account for error in launch origin
			float estTimeToHit = sys.fabs( delta_z / velocity_z );
			vector newVelocity = delta * ( velocity_z / delta_z );
			newVelocity_z = velocity_z;
			item.setLinearVelocity( newVelocity );
		}
	}
	
	item.enableKnockback();
	if ( parachute != $null_entity ) {
		parachute.vForceStayOpen( false );
	}

	if ( requestId != -1 ) {
		sys.clearDeployRequest( requestId );
		requestId = -1;
	}

	if ( item != $null_entity ) {
		item.vOnDeploy();
		item = $null_entity;
	}
}

object vehicle_jotun {
	void			preinit();
	void			init();
	void			destroy();
	void			syncFields();

	// states
	void			Deliver();
	void			Drop();
	void			Return();

	// callbacks
	void			OnSetDeploymentParms( float deploymentItemIndex, float playerIndex, vector target, float rotation );
	void			OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location );
	void			ClearRequest();
	void			OnItemChanged();
	void			OnStartTimeChanged();

	// utility
	void			DoSound();
	void			SetupCommandMap();
	boolean			PerformDrop();
	
	// virtuals
	boolean			vIgnoreMagogCollsion();

	// threads
	void			KillAllInBoundingBox();
	
	// deployment stuff
	float			deployIndex;
	float			deployPlayerIndex;
	float			itemIndex;
	entity			item;
	vector			targetPos;
	float			itemRotation;
	float			startTime;
	float			dropTime;
	float			returnTime;
	vector			gdfCorner;
	
	float			deliveryPathLength;
	float			returnPathLength;

	// local data	
	float			maxHealth;
	float			damageIndex;

	boolean			cancelDrop;
	boolean			dropped;
	
	boolean			playedFlyBySound;
	boolean			playingFlySound;
	float			flyOverSoundRange;
};


void vehicle_jotun::SetupCommandMap() {

}

void vehicle_jotun::syncFields() {
	syncBroadcast( "item" );
	syncBroadcast( "dropTime" );
	syncBroadcast( "returnTime" );
	syncBroadcast( "targetPos" );
	syncBroadcast( "itemRotation" );
	syncBroadcast( "gdfCorner" );
	syncBroadcast( "startTime" );
	syncCallback( "item", "OnItemChanged" );
	syncCallback( "startTime", "OnStartTimeChanged" );
}

void vehicle_jotun::OnItemChanged() {
}

void vehicle_jotun::OnStartTimeChanged() {
	if ( startTime != -1 ) {
		setState( "Deliver" );
	}
}

void vehicle_jotun::preinit() {
	deployPlayerIndex = -1;
	startTime = -1;
	dropTime = -1;
	returnTime = -1;
	maxHealth				= getFloatKey( "health" );

	SetupCommandMap();
	
	float damageDeclIndex		= sys.getDeclType( "damageDef" );
	damageIndex					= sys.getDeclIndex( damageDeclIndex, getKey( "dmg_drop_damage" ) );
	
	gdfCorner = '0 0 0';

	cancelDrop		= false;
	dropped 		= false;

	playedFlyBySound	= false;
	playingFlySound		= false;

	flyOverSoundRange	= getFloatKey( "flyover_sndrange" );
	flyOverSoundRange	= flyOverSoundRange * flyOverSoundRange;

	setCoverage( 0.f );

	disableKnockback();
	hide();
}

void vehicle_jotun::init() {
	thread KillAllInBoundingBox();
}

void vehicle_jotun::ClearRequest() {
	if ( sys.isClient() ) {
		return;
	}
	
	if ( deployPlayerIndex != -1 ) {
		sys.clearDeployRequest( deployPlayerIndex );
		deployPlayerIndex = -1;
	}
}

void vehicle_jotun::destroy() {	
	sys.killThread( "KillAllInBoundingBox_" + getName() );

	ClearRequest();
}

#define JOTUN_FLY_HEIGHT			4096

void vehicle_jotun::Deliver() {
	show();

	if ( !sys.isClient() ) {
		startTime = sys.getTime();
		gdfCorner = objManager.GetGDFBasePosition();
	}
	
	float pathSpeed = getFloatKeyWithDefault( "path_speed", 1024 );
	string pathType = getKey( "path_type" );

	// find the delivery path & level it out
	pathFind( pathType, targetPos, startTime, 1.0f, gdfCorner_x, gdfCorner_y, 256.0f, false );
	pathLevel( 13, -1, -1 );
	float numPoints = pathGetNumPoints();
	if ( numPoints < 2 ) {
		return;
	}
	
	deliveryPathLength = pathGetLength();
	
	// get the return path & level that out
	pathFind( pathType, targetPos, startTime + deliveryPathLength / pathSpeed, -1.0f, gdfCorner_x, gdfCorner_y, 1024.0f, true );
	float newNumPoints = pathGetNumPoints();
	pathLevel( 13, numPoints - 1, newNumPoints - 1 );

	returnPathLength = pathGetLength() - deliveryPathLength;
	
	float pathLength = deliveryPathLength;
	float leadTime = 2.0f;

	vector flyOffset = '0 0 0';
	flyOffset_z = JOTUN_FLY_HEIGHT;
	
	// setup the start
	vector startPoint = pathGetPoint( 0 ) + flyOffset;
	vector endPoint = pathGetPoint( numPoints - 1 ) + flyOffset;
	vector startDir = sys.vecNormalize( endPoint - startPoint );
	vector startAngles = sys.vecToAngles( startDir );
	
	setWorldOrigin( startPoint );
	setAngles( startAngles );

	startJotunDelivery( startTime, pathSpeed, leadTime );
	
	float minDistance = 9999999999.0f;
	float coverage = 0.f;
	while ( true ) {
		float time = sys.getTime() - startTime;
		float frameTime = sys.getFrameTime();
		
		setCoverage( coverage );
		coverage = coverage + frameTime;
	
//sys.debugCircle( '1 0 0', startPoint, '0 0 1', 256.0f, 16, 0 );
//sys.debugCircle( '1 0 0', endPoint, '0 0 1', 128.0f, 16, 0 );

		float aheadPosition = ( time + leadTime )* pathSpeed;

		DoSound();
		
		if ( !sys.isClient() ) {
			vector origin = getWorldOrigin();
			vector delta = origin - endPoint;
			delta_z = 0.0f;
			float distance = sys.vecLength( delta );
			
			if ( distance < minDistance ) {
				minDistance = distance;
			} else if ( aheadPosition > pathLength ) {
				Drop();
			}
		} else if ( returnTime != -1 ) {
			setState( "Return" );
		}
		
		if ( cancelDrop ) {
			ClearRequest();
			setState( "Return" );
		}
				
		sys.waitFrame();
	}
}

void vehicle_jotun::Drop() {
	
	player p = sys.getClient( deployPlayerIndex );
	item = sys.spawnType( itemIndex );
	item.vSetDeployableOwner( p );

	deployable_base deployable = item;
	if ( deployable != $null_entity ) {
		p.SetTargetingItem( item );
	}	

	string statName = item.getKey( "stat_name" );
	if ( statName != "" ) {
		sys.increaseStatInt( sys.allocStatInt( statName + "_deployed" ), deployPlayerIndex, 1 );
	}

	if( PerformDrop() ) {
		vector temp = getWorldOrigin();
		
		vector angles;
		angles_y = itemRotation;

		item.setOrigin( temp - ( g_vectorDown * 256 ) );
		item.setAngles( angles );
		item.setGameTeam( getGameTeam() );
		item.vSetManualDeploy();
		thread G_Jotun_DropItem( deployPlayerIndex, item, targetPos );
	} else {				
		item.remove();
		ClearRequest();
	}
	
	deployPlayerIndex = -1;
	dropped = true;
	
	setState( "Return" );
}

void vehicle_jotun::Return() {
	if ( !sys.isClient() ) {
		returnTime = sys.getTime();
	} else {
		while ( returnTime == -1 ) {
			sys.waitFrame();
		}
	}
	
	float numPoints = pathGetNumPoints();
	if ( numPoints < 2 ) {
		return;
	}
	
	float pathSpeed = getFloatKeyWithDefault( "path_speed", 1024 );
	float pathLength = returnPathLength;
	float leadTime = 2.0f;

	vector flyOffset = '0 0 0';
	flyOffset_z = JOTUN_FLY_HEIGHT;
	
	vector endPoint = pathGetPoint( numPoints - 1 ) + flyOffset;
	startJotunReturn( returnTime, pathSpeed, leadTime );
	
	while ( true ) {	
		DoSound();
		
		float time = sys.getTime() - returnTime;
		float position = time * pathSpeed;
		setCoverage( ( pathLength - 1 - position ) / pathSpeed );

		if ( !sys.isClient() ) {
			if ( position > pathLength ) {
				remove();
			}
		}
		
		sys.waitFrame();
	}
}

void vehicle_jotun::DoSound() {
	if( !playingFlySound ) {
		playingFlySound = true;
		fadeSound( SND_VEHICLE_IDLE, -60.f, 0.f );
		startSound( "snd_flyby_far", SND_VEHICLE_IDLE );
		fadeSound( SND_VEHICLE_IDLE, 0.f, 2.f );
	}

	// check distance to local player
	if( !playedFlyBySound ) {
		entity p = sys.getLocalPlayer();
		if( p != $null_entity ) {
			vector playerOrigin = p.getWorldOrigin();
			playerOrigin -= getWorldOrigin();
			playerOrigin_z = 0.f;

			if( sys.vecLengthSquared( playerOrigin ) < flyOverSoundRange ) {
				sys.startSoundDirect( getKey( "snd_flyby" ), SND_VEHICLE_IDLE );
				playedFlyBySound = true;
			}
		}
	}
}

void vehicle_jotun::OnSetDeploymentParms( float deploymentItemIndex, float playerIndex, vector target, float rotation ) {	

	deployPlayerIndex	= playerIndex;
	targetPos			= target;
	itemRotation		= sys.angleNormalize180( rotation );
	itemIndex			= deploymentItemIndex;

	if( !PerformDrop() ) {
		// player has switched sides since calling in the deployable
		ClearRequest();
		remove();
		return;
	}

	player p = sys.getClient( playerIndex );

	setState( "Deliver" );
}

void vehicle_jotun::OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location ) {
}

void vehicle_jotun::KillAllInBoundingBox() {
	sys.threadName( "KillAllInBoundingBox_" + getName() );

	sys.wait( 3 );

	eachFrame {

		vector mins = getAbsMins();
		vector maxs = getAbsMaxs();

//		sys.debugBounds( '1 1 1', mins, maxs, 0.f );

		float count = entitiesInBounds( mins, maxs, MASK_ALL, 1 );
		count = filterEntitiesByClass( "sdTransport", 1 );
		
		float i;
		for( i = 0; i < count; i++ ) {
			entity ent = getBoundsCacheEntity( i );
			if( ent == self || ent == item || ent == $null_entity ) {
				continue;
			}

			if( !ent.vIgnoreMagogCollsion() ) {
				ent.applyDamage( $null_entity, self, '0 1 0', GetDamage( "damage_magog_npc_collide" ), 60000.f, $null_entity );
			}
		}
	}
}

boolean vehicle_jotun::vIgnoreMagogCollsion() {
	return true;
}

boolean vehicle_jotun::PerformDrop() {
	return true;
}

void vehicle_jotun::vCancelDeployForPlayer( float playerIndex ) {
	if ( playerIndex != deployPlayerIndex ) {
		return;
	}
	
	// deployables already gone
	if ( dropped ) {
		return;
	}

	player p = sys.getClient( deployPlayerIndex );
	objManager.PlaySoundForPlayer( getKey( "snd_cancel_deploy" ), p );
	
	ClearRequest();
	setState( "Return" );
}