// FILE :    TaskShellShocked.cpp
// PURPOSE : Combat subtask in control of being shell-shocked
// CREATED : 3/12/2012

// File header
#include "Task/Combat/Subtasks/TaskShellShocked.h"

// Game headers
#include "animation/EventTags.h"
#include "animation/Move.h"
#include "animation/MovePed.h"
#include "event/EventDamage.h"
#include "Peds/ped.h"
#include "Peds/PedIntelligence.h"
#include "weapons/inventory/PedWeaponManager.h"

AI_OPTIMISATIONS()

//=========================================================================
// CTaskShellShocked
//=========================================================================

//Static Initialization -- MoVE
fwMvBooleanId CTaskShellShocked::ms_StaggerClipEndedId("StaggerClipEnded",0xD7D657B9);

fwMvClipId CTaskShellShocked::ms_StaggerClipId("StaggerClip",0xFEBBD768);

fwMvFlagId CTaskShellShocked::ms_ShortId("Short",0x9D43FEE8);
fwMvFlagId CTaskShellShocked::ms_LongId("Long",0xDAA2D5EC);
fwMvFlagId CTaskShellShocked::ms_FrontId("Front",0x89F230A2);
fwMvFlagId CTaskShellShocked::ms_BackId("Back",0x37418674);
fwMvFlagId CTaskShellShocked::ms_LeftId("Left",0x6FA34840);
fwMvFlagId CTaskShellShocked::ms_RightId("Right",0xB8CCC339);

fwMvFloatId CTaskShellShocked::ms_RateId("Rate",0x7E68C088);
fwMvFloatId CTaskShellShocked::ms_PhaseId("Phase",0xA27F482B);

fwMvRequestId CTaskShellShocked::ms_StaggerId("Stagger",0xEE57898E);

CTaskShellShocked::CTaskShellShocked(Vec3V_In vPosition, Duration nDuration, fwFlags8 uConfigFlags)
: m_ClipSetRequestHelper()
, m_MoveNetworkHelper()
, m_vPosition(vPosition)
, m_nDuration(nDuration)
, m_nDirection(CDirectionHelper::D_Invalid)
, m_ClipSetId(CLIP_SET_ID_INVALID)
, m_uConfigFlags(uConfigFlags)
{
	SetInternalTaskType(CTaskTypes::TASK_SHELL_SHOCKED);
}

CTaskShellShocked::~CTaskShellShocked()
{
}

void CTaskShellShocked::CleanUp()
{
	//Grab the ped.
	CPed* pPed = GetPed();

	//Ensure the ped is valid.
	if(pPed)
	{
		//Check if the move network is active.
		if(m_MoveNetworkHelper.IsNetworkActive())
		{	
			//Clear the move network.
			pPed->GetMovePed().ClearTaskNetwork(m_MoveNetworkHelper, NORMAL_BLEND_DURATION);
		}
	}
}

aiTask* CTaskShellShocked::Copy() const
{
	return rage_new CTaskShellShocked(m_vPosition, m_nDuration, m_uConfigFlags);
}

bool CTaskShellShocked::IsValid(const CPed& rPed, Vec3V_In vPosition)
{
	//Ensure we are not running normally.
	if(!rPed.GetMotionData()->GetIsLessThanRun() && !rPed.IsStrafing())
	{
		return false;
	}

	//Ensure we are not fleeing.
	if(rPed.GetPedIntelligence()->GetQueriableInterface()->IsTaskCurrentlyRunning(CTaskTypes::TASK_SMART_FLEE, true) ||
		rPed.GetPedIntelligence()->GetQueriableInterface()->IsTaskCurrentlyRunning(CTaskTypes::TASK_REACT_AND_FLEE, true))
	{
		return false;
	}

	//Ensure the clip set is valid.
	if(ChooseClipSet(rPed) == CLIP_SET_ID_INVALID)
	{
		return false;
	}

	//Ensure the direction is valid.
	if(ChooseDirection(rPed, vPosition, false) == CDirectionHelper::D_Invalid)
	{
		return false;
	}
	
	return true;
}

#if !__FINAL
const char* CTaskShellShocked::GetStaticStateName(s32 iState)
{
	Assert(iState >= State_Start && iState <= State_Finish);
	static const char* aStateNames[] = 
	{
		"State_Start",
		"State_Stream",
		"State_Stagger",
		"State_Finish",
	};

	return aStateNames[iState];
}
#endif

CTask::FSM_Return CTaskShellShocked::ProcessPreFSM()
{
	//Process the streaming.
	ProcessStreaming();
	
	return FSM_Continue;
}

CTask::FSM_Return CTaskShellShocked::UpdateFSM(const s32 iState, const FSM_Event iEvent)
{
	FSM_Begin
		FSM_State(State_Start)
			FSM_OnEnter
				Start_OnEnter();
			FSM_OnUpdate
				return Start_OnUpdate();
				
		FSM_State(State_Stream)
			FSM_OnUpdate
				return Stream_OnUpdate();
				
		FSM_State(State_Stagger)
			FSM_OnEnter
				Stagger_OnEnter();
			FSM_OnUpdate
				return Stagger_OnUpdate();
		
		FSM_State(State_Finish)
			FSM_OnUpdate
				return FSM_Quit;
		
	FSM_End
}

void CTaskShellShocked::Start_OnEnter()
{
	//Choose the clip set.
	m_ClipSetId = ChooseClipSet(*GetPed());

	//Choose the direction.
	m_nDirection = ChooseDirection(*GetPed(), m_vPosition, true);
}

CTask::FSM_Return CTaskShellShocked::Start_OnUpdate()
{
	//Ensure the clip set is valid.
	if(m_ClipSetId == CLIP_SET_ID_INVALID)
	{
		return FSM_Quit;
	}

	//Ensure the direction is valid.
	if(m_nDirection == CDirectionHelper::D_Invalid)
	{
		return FSM_Quit;
	}
	
	//Move to the stream state.
	SetState(State_Stream);
	
	return FSM_Continue;
}

CTask::FSM_Return CTaskShellShocked::Stream_OnUpdate()
{
	//Stream the MoVE network.
	bool bNetworkIsStreamedIn = fwAnimDirector::RequestNetworkDef(CClipNetworkMoveInfo::ms_NetworkTaskShellShocked);

	//Stream the clip set.
	bool bClipSetIsStreamedIn = m_ClipSetRequestHelper.IsLoaded();
	
	//Check if everything is streamed in.
	if(bNetworkIsStreamedIn && bClipSetIsStreamedIn)
	{
		//Grab the ped.
		CPed* pPed = GetPed();

		//Set up the move network on the ped.
		m_MoveNetworkHelper.CreateNetworkPlayer(pPed, CClipNetworkMoveInfo::ms_NetworkTaskShellShocked);
		pPed->GetMovePed().SetTaskNetwork(m_MoveNetworkHelper.GetNetworkPlayer(), NORMAL_BLEND_DURATION);
		
		//Set the clip set.
		m_MoveNetworkHelper.SetClipSet(m_ClipSetId);
		
		//Move to the stagger state.
		SetState(State_Stagger);
	}

	return FSM_Continue;
}

void CTaskShellShocked::Stagger_OnEnter()
{
	//Check if we should make the ped fatigued.
	if(ShouldMakeFatigued())
	{
		//Make the ped fatigued.
		MakeFatigued();
	}

	//Set the duration.
	switch(m_nDuration)
	{
		case Duration_Short:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_ShortId);
			break;
		}
		case Duration_Long:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_LongId);
			break;
		}
		default:
		{
			taskAssertf(false, "Unknown duration: %d.", m_nDuration);
			break;
		}
	}
	
	//Set the rate.
	static dev_float s_fMinRate = 0.8f;
	static dev_float s_fMaxRate = 1.2f;
	fwRandom::SetRandomSeed(GetPed()->GetRandomSeed());
	m_MoveNetworkHelper.SetFloat(ms_RateId, fwRandom::GetRandomNumberInRange(s_fMinRate, s_fMaxRate));
	
	//Check the direction.
	switch(m_nDirection)
	{
		case CDirectionHelper::D_FrontLeft:
		case CDirectionHelper::D_FrontRight:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_FrontId);
			break;
		}
		case CDirectionHelper::D_BackLeft:
		case CDirectionHelper::D_BackRight:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_BackId);
			break;
		}
		case CDirectionHelper::D_Left:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_LeftId);
			break;
		}
		case CDirectionHelper::D_Right:
		{
			m_MoveNetworkHelper.SetFlag(true, ms_RightId);
			break;
		}
		default:
		{
			taskAssertf(false, "Unknown direction: %d.", m_nDirection);
			break;
		}
	}
	
	//Send the stagger request.
	m_MoveNetworkHelper.SendRequest(ms_StaggerId);
	
	//Wait for the stagger clip to end.
	m_MoveNetworkHelper.WaitForTargetState(ms_StaggerClipEndedId);
}

CTask::FSM_Return CTaskShellShocked::Stagger_OnUpdate()
{
	//Check if the target state has been reached, or we should interrupt.
	if(m_MoveNetworkHelper.IsInTargetState() || ShouldInterrupt())
	{
		//Finish the task.
		SetState(State_Finish);
	}
	
	return FSM_Continue;
}

void CTaskShellShocked::MakeFatigued()
{
	taskAssert(ShouldMakeFatigued());

	//Ensure the ped is not already fatigued.
	float fHealth = GetPed()->GetHealth();
	float fThreshold = GetPed()->GetFatiguedHealthThreshold();
	float fDifference = fHealth - fThreshold;
	if(fDifference <= 0.0f)
	{
		return;
	}

	//Create the damage event.
	CEventDamage tempDamageEvent(NULL, fwTimer::GetTimeInMilliseconds(), WEAPONTYPE_FALL);

	//Apply the damage.
	float fDamage = fDifference + 1.0f;
	CPedDamageCalculator damageCalculator(NULL, fDamage, WEAPONTYPE_FALL, RAGDOLL_HEAD, false);
	damageCalculator.ApplyDamageAndComputeResponse(GetPed(), tempDamageEvent.GetDamageResponseData(), CPedDamageCalculator::DF_None);
}

void CTaskShellShocked::ProcessStreaming()
{
	//Stream the clip set.
	m_ClipSetRequestHelper.Request(m_ClipSetId);
}

bool CTaskShellShocked::ShouldInterrupt() const
{
	//Ensure the flag is set.
	if(!m_uConfigFlags.IsFlagSet(CF_Interrupt))
	{
		return false;
	}
	
	//Ensure the clip is valid.
	const crClip* pClip = m_MoveNetworkHelper.GetClip(ms_StaggerClipId);
	if(!pClip)
	{
		return false;
	}
	
	//Find the event phase.
	float fInterruptiblePhase;
	if(!CClipEventTags::FindEventPhase(pClip, CClipEventTags::Interruptible, fInterruptiblePhase))
	{
		return false;
	}
	
	//Ensure the phase has exceeded the interruptible phase.
	float fPhase = m_MoveNetworkHelper.GetFloat(ms_PhaseId);
	if(fPhase < fInterruptiblePhase)
	{
		return false;
	}
	
	return true;
}

bool CTaskShellShocked::ShouldMakeFatigued() const
{
	//Ensure the config flag is not set.
	if(m_uConfigFlags.IsFlagSet(CF_DisableMakeFatigued))
	{
		return false;
	}

	//Ensure the ped is random.
	if(!GetPed()->PopTypeIsRandom())
	{
		return false;
	}

	return true;
}

fwMvClipSetId CTaskShellShocked::ChooseClipSet(const CPed& rPed)
{
	//Ensure the weapon manager is valid.
	const CPedWeaponManager* pWeaponManager = rPed.GetWeaponManager();
	if(!pWeaponManager)
	{
		return CLIP_SET_ID_INVALID;
	}
	
	//Ensure the equipped weapon info is valid.
	const CWeaponInfo* pWeaponInfo = pWeaponManager->GetEquippedWeaponInfo();
	if(!pWeaponInfo)
	{
		return CLIP_SET_ID_INVALID;
	}
	
	return pWeaponInfo->GetShellShockedClipSetId(rPed);
}

CDirectionHelper::Direction CTaskShellShocked::ChooseDirection(const CPed& rPed, Vec3V_In vPosition, bool bUpdateTime)
{
	//Calculate the closest direction.
	CDirectionHelper::Direction nDirection = CDirectionHelper::CalculateClosestDirection(
		rPed.GetTransform().GetPosition(), rPed.GetCurrentHeading(), vPosition);
	taskAssert(nDirection != CDirectionHelper::D_Invalid);

	//Ensure the ped is on-screen.
	if(!rPed.GetPedConfigFlag(CPED_CONFIG_FLAG_VisibleOnScreen))
	{
		return nDirection;
	}

	//Get the left/right directions.
	CDirectionHelper::Direction nDirectionToLeft	= CDirectionHelper::MoveDirectionToLeft(nDirection);
	CDirectionHelper::Direction nDirectionToRight	= CDirectionHelper::MoveDirectionToRight(nDirection);
	taskAssert(nDirectionToLeft		!= CDirectionHelper::D_Invalid);
	taskAssert(nDirectionToRight	!= CDirectionHelper::D_Invalid);

	//Choose the direction that was used furthest in the past.
	static u32 s_uTimes[CDirectionHelper::D_Max];
	static bool s_bInitialized = false;
	if(!s_bInitialized)
	{
		s_bInitialized = true;

		for(int i = 0; i < CDirectionHelper::D_Max; ++i)
		{
			s_uTimes[i] = 0;
		}
	}

	//Choose the best time.
	u32 uTime			= s_uTimes[nDirection];
	u32 uTimeToLeft		= s_uTimes[nDirectionToLeft];
	u32 uTimeToRight	= s_uTimes[nDirectionToRight];
	u32 uTimeBest		= Min(Min(uTime, uTimeToLeft), uTimeToRight);

	//Choose a direction.
	static const int s_iMaxDirections = 3;
	CDirectionHelper::Direction aDirections[s_iMaxDirections];
	int iNumDirections = 0;

	//Check the directions.
	if(uTimeBest == uTime)
	{
		aDirections[iNumDirections++] = nDirection;
	}
	else if(uTimeBest == uTimeToLeft)
	{
		aDirections[iNumDirections++] = nDirectionToLeft;
	}
	else if(uTimeBest == uTimeToRight)
	{
		aDirections[iNumDirections++] = nDirectionToRight;
	}

	//Ensure the directions are valid.
	if(iNumDirections <= 0)
	{
		return nDirection;
	}

	//Choose a direction.
	fwRandom::SetRandomSeed(rPed.GetRandomSeed());
	int iIndex = fwRandom::GetRandomNumberInRange(0, iNumDirections);
	CDirectionHelper::Direction nDirectionToUse = aDirections[iIndex];

	//Set the time.
	if(bUpdateTime && (nDirectionToUse != CDirectionHelper::D_Invalid))
	{
		s_uTimes[nDirectionToUse] = fwTimer::GetTimeInMilliseconds();
	}

	return nDirectionToUse;
}