//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:	Squad classes
//
//=============================================================================//

#ifndef AI_SQUAD_H
#define AI_SQUAD_H

#include "ai_memory.h"
#include "ai_squadslot.h"
#include "bitstring.h"

class CAI_Squad;
typedef CHandle<CAI_BaseNPC> AIHANDLE;

#define PER_ENEMY_SQUADSLOTS 1


//-----------------------------------------------------------------------------

DECLARE_POINTER_HANDLE(AISquadsIter_t);
DECLARE_POINTER_HANDLE(AISquadIter_t);

#define	MAX_SQUAD_MEMBERS	16
#define MAX_SQUAD_DATA_SLOTS 4

//-----------------------------------------------------------------------------
// CAI_SquadManager
//
// Purpose: Manages all the squads in the system
//
//-----------------------------------------------------------------------------

class CAI_SquadManager
{
public:
	CAI_SquadManager()
	{
		m_pSquads = NULL;
	}

	CAI_Squad *		GetFirstSquad( AISquadsIter_t *pIter );
	CAI_Squad *		GetNextSquad( AISquadsIter_t *pIter );
	int				NumSquads();

	CAI_Squad *		FindSquad( string_t squadName );	// Returns squad of the given name
	CAI_Squad *		CreateSquad( string_t squadName );	// Returns squad of the given name
	CAI_Squad *		FindCreateSquad( string_t squadName );	// Returns squad of the given name
	CAI_Squad *		FindCreateSquad( CAI_BaseNPC *pNPC, string_t squadName );	// Returns squad of the given name

	void			DeleteSquad( CAI_Squad *pSquad );
	void			DeleteAllSquads(void);

private:

	CAI_Squad *		m_pSquads;										// A linked list of all squads

};

//-------------------------------------

extern CAI_SquadManager g_AI_SquadManager;

//-----------------------------------------------------------------------------

#ifdef PER_ENEMY_SQUADSLOTS

struct AISquadEnemyInfo_t
{
	EHANDLE 						hEnemy;
	CBitVec<MAX_SQUADSLOTS>	slots;									// What squad slots are filled?

	DECLARE_SIMPLE_DATADESC();
};

#endif

//-----------------------------------------------------------------------------
// CAI_Squad
//
// Purpose: Tracks enemies, squad slots, squad members
//
//-----------------------------------------------------------------------------

class CAI_Squad
{
public:

	const char *			GetName() const	{ return STRING(m_Name); }

	void					RemoveFromSquad( CAI_BaseNPC *pNPC, bool bDeath = false );

	CAI_BaseNPC *			GetFirstMember( AISquadIter_t *pIter = NULL, bool bIgnoreSilentMembers = true );
	CAI_BaseNPC *			GetNextMember( AISquadIter_t *pIter, bool bIgnoreSilentMembers = true );
	CAI_BaseNPC *			GetAnyMember();
	int						NumMembers( bool bIgnoreSilentMembers = true );
	int						GetSquadIndex( CAI_BaseNPC * );

	void					SquadNewEnemy ( CBaseEntity *pEnemy );
	void					UpdateEnemyMemory( CAI_BaseNPC *pUpdater, CBaseEntity *pEnemy, const Vector &position );

	bool 					OccupyStrategySlotRange( CBaseEntity *pEnemy, int slotIDStart, int slotIDEnd, int *pSlot );
	void 					VacateStrategySlot( CBaseEntity *pEnemy, int slot);
	bool					IsStrategySlotRangeOccupied( CBaseEntity *pEnemy, int slotIDStart, int slotIDEnd );
	
	CAI_BaseNPC	*			SquadMemberInRange( const Vector &vecLocation, float flDist );
	CAI_BaseNPC *			NearestSquadMember( CAI_BaseNPC *pMember );
	int						GetVisibleSquadMembers( CAI_BaseNPC *pMember );
	CAI_BaseNPC *			GetSquadMemberNearestTo( const Vector &vecLocation );
	bool					SquadIsMember( CBaseEntity *pMember );
	bool					IsLeader( CAI_BaseNPC *pLeader );
	CAI_BaseNPC				*GetLeader( void );

	Vector					ComputeSquadCentroid( bool bIncludeSilentMembers, CBaseCombatCharacter *pExcludeMember );

	int						BroadcastInteraction( int interactionType, void *data, CBaseCombatCharacter *sender = NULL );

	void					AddToSquad(CAI_BaseNPC *pNPC);
	bool					FOkToMakeSound( int soundPriority );
	void					JustMadeSound( int soundPriority, float time );
	float					GetSquadSoundWaitTime() const		{ return m_flSquadSoundWaitTime; }
	void					SetSquadSoundWaitTime( float time ) { m_flSquadSoundWaitTime = time; }
	void					SquadRemember( int iMemory );

	void					SetSquadInflictor( CBaseEntity *pInflictor );
	bool					IsSquadInflictor( CBaseEntity *pInflictor );

	static bool				IsSilentMember( const CAI_BaseNPC *pNPC );

	template <typename T>
	void					SetSquadData( unsigned slot, const T &data )
	{
		Assert( slot < MAX_SQUAD_DATA_SLOTS );
		if ( slot < MAX_SQUAD_DATA_SLOTS )
		{
			m_SquadData[slot] = *((int *)&data);
		}
	}

	template <typename T>
	void					GetSquadData( unsigned slot, T *pData )
	{
		Assert( slot < MAX_SQUAD_DATA_SLOTS );
		if ( slot < MAX_SQUAD_DATA_SLOTS )
		{
			*pData = *((T *)&m_SquadData[slot]);
		}
	}


private:
	void OccupySlot( CBaseEntity *pEnemy, int i );
	void VacateSlot( CBaseEntity *pEnemy, int i );
	bool IsSlotOccupied( CBaseEntity *pEnemy, int i ) const;

private:
	friend class CAI_SaveRestoreBlockHandler;
	friend class CAI_SquadManager;

	CAI_Squad();
	CAI_Squad(string_t squadName);
	~CAI_Squad(void);

	CAI_Squad*				GetNext() { return m_pNextSquad; }

	void Init( string_t squadName );

	CAI_Squad *										m_pNextSquad;								// The next squad is list of all squads

	string_t										m_Name;
	CUtlVectorFixed<AIHANDLE, MAX_SQUAD_MEMBERS>	m_SquadMembers;

	float											m_flSquadSoundWaitTime;			// Time when I'm allowed to make another sound
	int												m_nSquadSoundPriority;			// if we're still waiting, this is the priority of the current sound

	EHANDLE											m_hSquadInflictor;

	int												m_SquadData[MAX_SQUAD_DATA_SLOTS];

#ifdef PER_ENEMY_SQUADSLOTS

	AISquadEnemyInfo_t *FindEnemyInfo( CBaseEntity *pEnemy );
	const AISquadEnemyInfo_t *FindEnemyInfo( CBaseEntity *pEnemy ) const	{ return const_cast<CAI_Squad *>(this)->FindEnemyInfo( pEnemy ); }

	AISquadEnemyInfo_t *			m_pLastFoundEnemyInfo; // Occupy/Vacate need to be reworked to not want this
	
	CUtlVector<AISquadEnemyInfo_t>	m_EnemyInfos;
	float							m_flEnemyInfoCleanupTime;

#else
	
	CVarBitVec	m_squadSlotsUsed;							// What squad slots are filled?

#endif

	//---------------------------------
public:
	DECLARE_SIMPLE_DATADESC();
};

//-----------------------------------------------------------------------------
//
// Purpose: CAI_SquadManager inline functions
//
//-----------------------------------------------------------------------------

inline CAI_Squad *CAI_SquadManager::GetFirstSquad( AISquadsIter_t *pIter )
{
	*pIter = (AISquadsIter_t)m_pSquads;
	return m_pSquads;
}

//-------------------------------------

inline CAI_Squad *CAI_SquadManager::GetNextSquad( AISquadsIter_t *pIter )
{
	CAI_Squad *pSquad = (CAI_Squad *)*pIter;
	if ( pSquad )
		pSquad = pSquad->m_pNextSquad;
	*pIter = (AISquadsIter_t)pSquad;
	return pSquad;
}

//-------------------------------------
// Purpose: Returns squad of the given name or creates a new squad with the
//			given name if none exists and add pNPC to the list of members
//-------------------------------------

inline CAI_Squad *CAI_SquadManager::FindCreateSquad(CAI_BaseNPC *pNPC, string_t squadName)
{
	CAI_Squad* pSquad = FindSquad( squadName );
	
	if ( !pSquad )
		pSquad = CreateSquad( squadName );
	
	pSquad->AddToSquad( pNPC );

	return pSquad;
}

//-----------------------------------------------------------------------------

inline CAI_Squad *CAI_SquadManager::FindCreateSquad(string_t squadName)
{
	CAI_Squad* pSquad = FindSquad( squadName );
	
	if ( !pSquad )
		pSquad = CreateSquad( squadName );
	
	return pSquad;
}

//-------------------------------------

inline CAI_BaseNPC *CAI_Squad::GetAnyMember()
{
	if ( m_SquadMembers.Count() )
		return m_SquadMembers[random->RandomInt( 0, m_SquadMembers.Count()-1 )];
	return NULL;
}

//-------------------------------------

inline int CAI_Squad::GetSquadIndex( CAI_BaseNPC *pAI )
{
	for ( int i = 0; i < m_SquadMembers.Count(); i++ )
	{
		if ( m_SquadMembers[i] == pAI )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------

#endif // AI_SQUAD_H