#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "../Game_local.h"

class rvMonsterGunner : public idAI {
public:

	CLASS_PROTOTYPE( rvMonsterGunner );

	rvMonsterGunner ( void );

	void				InitSpawnArgsVariables			( void );
	void				Spawn							( void );
	void				Save							( idSaveGame *savefile ) const;
	void				Restore							( idRestoreGame *savefile );

	// Add some dynamic externals for debugging
	virtual void		GetDebugInfo					( debugInfoProc_t proc, void* userData );

	virtual bool		Pain							( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );

protected:

	int					shots;
	int					shotsFired;
	idStr				nailgunPrefix;
	int					nailgunMinShots;
	int					nailgunMaxShots;
	int					nextShootTime;
	int					attackRate;
	jointHandle_t		attackJoint;

	virtual void		OnStopMoving					( aiMoveCommand_t oldMoveCommand );
	virtual bool		UpdateRunStatus					( void );

	virtual int			FilterTactical					( int availableTactical );

	virtual bool		CheckActions					( void );
	virtual void		OnTacticalChange				( aiTactical_t oldTactical );

private:

	// Actions
	rvAIAction			actionGrenadeAttack;
	rvAIAction			actionNailgunAttack;

	rvAIAction			actionSideStepLeft;
	rvAIAction			actionSideStepRight;
	rvAIActionTimer		actionTimerSideStep;

	bool				CheckAction_SideStepLeft		( rvAIAction* action, int animNum );
	bool				CheckAction_SideStepRight		( rvAIAction* action, int animNum );

	// Torso States
	stateResult_t		State_Torso_NailgunAttack		( const stateParms_t& parms );
	stateResult_t		State_Torso_MovingRangedAttack	( const stateParms_t& parms );

	CLASS_STATES_PROTOTYPE ( rvMonsterGunner );
};

CLASS_DECLARATION( idAI, rvMonsterGunner )
END_CLASS

/*
================
rvMonsterGunner::rvMonsterGunner
================
*/
rvMonsterGunner::rvMonsterGunner ( ) {
	nextShootTime = 0;
}


void rvMonsterGunner::InitSpawnArgsVariables( void )
{
	nailgunMinShots = spawnArgs.GetInt ( "action_nailgunAttack_minshots", "5" );
	nailgunMaxShots = spawnArgs.GetInt ( "action_nailgunAttack_maxshots", "20" );
	attackRate = SEC2MS( spawnArgs.GetFloat( "attackRate", "0.3" ) );
	attackJoint = animator.GetJointHandle( spawnArgs.GetString( "attackJoint", "muzzle" ) );
}
/*
================
rvMonsterGunner::Spawn
================
*/
void rvMonsterGunner::Spawn ( void ) {
	actionGrenadeAttack.Init ( spawnArgs, "action_grenadeAttack", NULL, AIACTIONF_ATTACK );
	actionNailgunAttack.Init ( spawnArgs, "action_nailgunAttack", "Torso_NailgunAttack", AIACTIONF_ATTACK );
	actionSideStepLeft.Init ( spawnArgs, "action_sideStepLeft", NULL, 0 );
	actionSideStepRight.Init ( spawnArgs, "action_sideStepRight", NULL, 0 );
	actionTimerSideStep.Init ( spawnArgs, "actionTimer_sideStep" );
	
	InitSpawnArgsVariables();
}

/*
================
rvMonsterGunner::Save
================
*/
void rvMonsterGunner::Save ( idSaveGame *savefile ) const {
	actionGrenadeAttack.Save ( savefile );
	actionNailgunAttack.Save ( savefile );
	actionSideStepLeft.Save ( savefile );
	actionSideStepRight.Save ( savefile );
	actionTimerSideStep.Save ( savefile );
	
	savefile->WriteInt ( shots );
	savefile->WriteInt ( shotsFired );
	savefile->WriteString ( nailgunPrefix );
	savefile->WriteInt ( nextShootTime );
}

/*
================
rvMonsterGunner::Restore
================
*/
void rvMonsterGunner::Restore ( idRestoreGame *savefile ) {
	actionGrenadeAttack.Restore ( savefile );
	actionNailgunAttack.Restore ( savefile );
	actionSideStepLeft.Restore ( savefile );
	actionSideStepRight.Restore ( savefile );
	actionTimerSideStep.Restore ( savefile );
	
	savefile->ReadInt ( shots );
	savefile->ReadInt ( shotsFired );
	savefile->ReadString ( nailgunPrefix );
	savefile->ReadInt ( nextShootTime );

	InitSpawnArgsVariables();
}

/*
============
rvMonsterGunner::OnStopMoving
============
*/
void rvMonsterGunner::OnStopMoving ( aiMoveCommand_t oldMoveCommand ) {
	//MCG - once you get to your position, attack immediately (no pause)
	//FIXME: Restrict this some?  Not after animmoves?  Not if move was short?  Only in certain tactical states?
	if ( GetEnemy() )
	{
		if ( combat.tacticalCurrent == AITACTICAL_HIDE )
		{//hiding
		}
		else if ( combat.tacticalCurrent == AITACTICAL_MELEE || enemy.range <= combat.meleeRange )
		{//in melee state or in melee range
			actionMeleeAttack.timer.Clear( actionTime );
		}
		else if ( (!actionNailgunAttack.timer.IsDone(actionTime) || !actionTimerRangedAttack.IsDone(actionTime))
			&& (!actionGrenadeAttack.timer.IsDone(actionTime) || !actionTimerSpecialAttack.IsDone(actionTime)) )
		{//no attack is ready
			//Ready at least one of them
			if ( gameLocal.random.RandomInt(3) )
			{
				actionNailgunAttack.timer.Clear( actionTime );
				actionTimerRangedAttack.Clear( actionTime );
			}
			else
			{
				actionGrenadeAttack.timer.Clear( actionTime );
				actionTimerSpecialAttack.Clear( actionTime );
			}
		}
	}
}

/*
================
rvMonsterGunner::UpdateRunStatus
================
*/
bool rvMonsterGunner::UpdateRunStatus ( void ) {
	move.fl.idealRunning = false;

	return move.fl.running != move.fl.idealRunning;
}

/*
================
rvMonsterGunner::FilterTactical
================
*/
int rvMonsterGunner::FilterTactical ( int availableTactical ) {
	if ( !move.fl.moving && enemy.range > combat.meleeRange )
	{//keep moving!
		if ( (!actionNailgunAttack.timer.IsDone(actionTime+500) || !actionTimerRangedAttack.IsDone(actionTime+500))
			&& (!actionGrenadeAttack.timer.IsDone(actionTime+500) || !actionTimerSpecialAttack.IsDone(actionTime+500)) )
		{//won't be attacking in the next 1 second
			combat.tacticalUpdateTime = 0;
			availableTactical |= (AITACTICAL_MELEE_BIT);
			if ( !gameLocal.random.RandomInt(2) )
			{
				availableTactical &= ~(AITACTICAL_RANGED_BITS);
			}
		}
	}
	
	return idAI::FilterTactical ( availableTactical );
}

/*
================
rvMonsterGunner::OnTacticalChange

Enable/Disable the ranged attack based on whether the grunt needs it
================
*/
void rvMonsterGunner::OnTacticalChange ( aiTactical_t oldTactical ) {
	switch ( combat.tacticalCurrent ) {
		case AITACTICAL_MELEE:
			//walk for at least 2 seconds (default update time of 500 is too short)
			combat.tacticalUpdateTime = gameLocal.GetTime() + 2000 + gameLocal.random.RandomInt(1000);
			break;
	}
}

/*
================
rvMonsterGunner::CheckAction_SideStepLeft
================
*/
bool rvMonsterGunner::CheckAction_SideStepLeft ( rvAIAction* action, int animNum ) {
	if ( animNum == -1 ) {
		return false;
	}
	idVec3 moveVec;
	TestAnimMove( animNum, NULL, &moveVec );
	//NOTE: should we care if we can't walk all the way to the left?
	int attAnimNum = -1;
	if ( actionNailgunAttack.anims.Num ( ) ) {
		// Pick a random animation from the list
		attAnimNum = GetAnim ( ANIMCHANNEL_TORSO, actionNailgunAttack.anims[gameLocal.random.RandomInt(actionNailgunAttack.anims.Num())] );
	}
	if ( attAnimNum != -1 && !CanHitEnemyFromAnim( attAnimNum, moveVec ) ) {
		return false;
	}
	return true;
}

/*
================
rvMonsterGunner::CheckAction_SideStepRight
================
*/
bool rvMonsterGunner::CheckAction_SideStepRight ( rvAIAction* action, int animNum ) {
	if ( animNum == -1 ) {
		return false;
	}
	idVec3 moveVec;
	TestAnimMove ( animNum, NULL, &moveVec );
	//NOTE: should we care if we can't walk all the way to the right?
	int attAnimNum = -1;
	if ( actionNailgunAttack.anims.Num ( ) ) {
		// Pick a random animation from the list
		attAnimNum = GetAnim ( ANIMCHANNEL_TORSO, actionNailgunAttack.anims[gameLocal.random.RandomInt(actionNailgunAttack.anims.Num())] );
	}
	if ( attAnimNum != -1 && !CanHitEnemyFromAnim( attAnimNum, moveVec ) ) {
		return false;
	}
	return true;
}

/*
================
rvMonsterGunner::CheckActions
================
*/
bool rvMonsterGunner::CheckActions ( void ) {
	// Fire a grenade?
	if ( PerformAction ( &actionGrenadeAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerSpecialAttack ) ||
		 PerformAction ( &actionNailgunAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack )     )  {
		return true;
	}

	bool action = idAI::CheckActions( );
	if ( !action ) {
		//try a strafe
		if ( GetEnemy() && enemy.fl.visible && gameLocal.GetTime()-lastAttackTime > actionTimerRangedAttack.GetRate()+1000 ) {
			//we can see our enemy but haven't been able to shoot him in a while...
			if ( PerformAction ( &actionSideStepLeft, (checkAction_t)&rvMonsterGunner::CheckAction_SideStepLeft, &actionTimerSideStep )
				|| PerformAction ( &actionSideStepRight, (checkAction_t)&rvMonsterGunner::CheckAction_SideStepRight, &actionTimerSideStep ) ) {
				return true;
			}
		}
	}
	return action;
}

/*
=====================
rvMonsterGunner::GetDebugInfo
=====================
*/
void rvMonsterGunner::GetDebugInfo ( debugInfoProc_t proc, void* userData ) {
	// Base class first
	idAI::GetDebugInfo ( proc, userData );
	
	proc ( "idAI", "action_grenadeAttack",		aiActionStatusString[actionGrenadeAttack.status], userData );
	proc ( "idAI", "action_nailgunAttack",		aiActionStatusString[actionNailgunAttack.status], userData );
	proc ( "idAI", "actionSideStepLeft",		aiActionStatusString[actionSideStepLeft.status], userData );
	proc ( "idAI", "actionSideStepRight",		aiActionStatusString[actionSideStepRight.status], userData );
}

bool rvMonsterGunner::Pain( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
	actionTimerRangedAttack.Clear( actionTime );
	actionNailgunAttack.timer.Clear( actionTime );
	return (idAI::Pain( inflictor, attacker, damage, dir, location ));
}
/*
===============================================================================

	States 

===============================================================================
*/

CLASS_STATES_DECLARATION ( rvMonsterGunner )
	STATE ( "Torso_NailgunAttack",		rvMonsterGunner::State_Torso_NailgunAttack )
	STATE ( "Torso_MovingRangedAttack",	rvMonsterGunner::State_Torso_MovingRangedAttack )
END_CLASS_STATES

/*
================
rvMonsterGunner::State_Torso_MovingRangedAttack
================
*/
stateResult_t rvMonsterGunner::State_Torso_MovingRangedAttack ( const stateParms_t& parms ) {
	enum { 
		STAGE_INIT,
		STAGE_SHOOT,
		STAGE_SHOOT_WAIT,
	};
	switch ( parms.stage ) {
		case STAGE_INIT:
			shots = (gameLocal.random.RandomInt ( nailgunMaxShots - nailgunMinShots ) + nailgunMinShots) * combat.aggressiveScale;
			shotsFired = 0;
			return SRESULT_STAGE ( STAGE_SHOOT );
			
		case STAGE_SHOOT:
			shots--;
			shotsFired++;
			nextShootTime = gameLocal.GetTime() + attackRate;
			if ( attackJoint != INVALID_JOINT ) {
				Attack( "nail", attackJoint, GetEnemy() );
				PlayEffect( "fx_nail_flash", attackJoint );
			}
			StartSound( "snd_nailgun_fire", SND_CHANNEL_WEAPON, 0, false, 0 );
			/*
			switch ( move.currentDirection )
			{
			case MOVEDIR_RIGHT:
				PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_torso_right", 0 );
				break;
			case MOVEDIR_LEFT:
				PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_torso_left", 0 );
				break;
			case MOVEDIR_BACKWARD:
				PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_torso_back", 0 );
				break;
			default:
				PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_torso", 0 );
				break;
			}
			*/
			return SRESULT_STAGE ( STAGE_SHOOT_WAIT );
		
		case STAGE_SHOOT_WAIT:
			// When the shoot animation is done either play another shot animation
			// or finish up with post_shooting
			if ( gameLocal.GetTime() >= nextShootTime ) {
				if ( shots <= 0 || (!enemy.fl.inFov && shotsFired >= nailgunMinShots) || !move.fl.moving ) {
					return SRESULT_DONE;
				}
				return SRESULT_STAGE ( STAGE_SHOOT);
			}
			return SRESULT_WAIT;	
	}
	return SRESULT_ERROR; 
}


/*
================
rvMonsterGunner::State_Torso_NailgunAttack
================
*/
stateResult_t rvMonsterGunner::State_Torso_NailgunAttack ( const stateParms_t& parms ) {
	static const char* nailgunAnims [ ] = { "nailgun_short", "nailgun_long" };
	enum { 
		STAGE_INIT,
		STAGE_WAITSTART,
		STAGE_LOOP,
		STAGE_WAITLOOP,
		STAGE_WAITEND
	};
	switch ( parms.stage ) {
		case STAGE_INIT:
			// If moving switch to the moving ranged attack (torso only)
			if ( move.fl.moving && !actionNailgunAttack.fl.overrideLegs && FacingIdeal() && !gameLocal.random.RandomInt(1) ) {
				PostAnimState ( ANIMCHANNEL_TORSO, "Torso_MovingRangedAttack", parms.blendFrames );
				return SRESULT_DONE;
			}

			shots = (gameLocal.random.RandomInt ( nailgunMaxShots - nailgunMinShots ) + nailgunMinShots) * combat.aggressiveScale;
			DisableAnimState ( ANIMCHANNEL_LEGS );
			shotsFired = 0;
			nailgunPrefix = nailgunAnims[shots%2];
			if ( !CanHitEnemyFromAnim( GetAnim( ANIMCHANNEL_TORSO, va("%s_loop", nailgunPrefix.c_str() ) ) ) )
			{//this is hacky, but we really need to test the attack anim first since they're so different
				//can't hit with this one, just use the other one...
				nailgunPrefix = nailgunAnims[(shots+1)%2];
			}
			PlayAnim ( ANIMCHANNEL_TORSO, va("%s_start", nailgunPrefix.c_str() ), parms.blendFrames );
			return SRESULT_STAGE ( STAGE_WAITSTART );
			
		case STAGE_WAITSTART:
			if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
				return SRESULT_STAGE ( STAGE_LOOP );
			}
			return SRESULT_WAIT;
		
		case STAGE_LOOP:
			PlayAnim ( ANIMCHANNEL_TORSO, va("%s_loop", nailgunPrefix.c_str() ), 0 );
			shotsFired++;
			return SRESULT_STAGE ( STAGE_WAITLOOP );
		
		case STAGE_WAITLOOP:
			if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
				if ( --shots <= 0 || (shotsFired >= nailgunMinShots && !enemy.fl.inFov) || aifl.damage ) {
					PlayAnim ( ANIMCHANNEL_TORSO, va("%s_end", nailgunPrefix.c_str() ), 0 );
					return SRESULT_STAGE ( STAGE_WAITEND );
				}
				return SRESULT_STAGE ( STAGE_LOOP );
			}
			return SRESULT_WAIT;
		
		case STAGE_WAITEND:
			if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
				return SRESULT_DONE;
			}
			return SRESULT_WAIT;				
	}
	return SRESULT_ERROR; 
}