//===== Copyright � 1996-2005, Valve Corporation, All rights reserved. ======//

//

// Purpose: 

//

// $Workfile:     $

// $Date:         $

//

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

// $NoKeywords: $

//===========================================================================//

#ifndef CONVAR_H

#define CONVAR_H

#if _WIN32

#pragma once

#endif

#include "tier0/dbg.h"

#include "tier1/iconvar.h"

#include "tier1/utlvector.h"

#include "tier1/utlstring.h"

#include "Color.h"

#include "icvar.h"

#ifdef _WIN32

#define FORCEINLINE_CVAR FORCEINLINE

#elif POSIX

#define FORCEINLINE_CVAR inline

#else

#error "implement me"

#endif

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

// Uncomment me to test for threading issues for material system convars

// NOTE: You want to disable all threading when you do this

// +host_thread_mode 0 +r_threaded_particles 0 +sv_parallel_packentities 0 +sv_disable_querycache 0

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

//#define CONVAR_TEST_MATERIAL_THREAD_CONVARS 1

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

// Forward declarations

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

class ConVar;

class CCommand;

class ConCommand;

class ConCommandBase;

struct characterset_t;

struct CCommandContext

{

	CCommandContext( int index )

	{

		_index = index;

	}

	int Get() const

	{

		return _index;

	}

private:

	int _index;

};

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

// Any executable that wants to use ConVars need to implement one of

// these to hook up access to console variables.

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

class IConCommandBaseAccessor

{

public:

	// Flags is a combination of FCVAR flags in cvar.h.

	// hOut is filled in with a handle to the variable.

	virtual bool RegisterConCommandBase( ConCommandBase *pVar ) = 0;

};

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

// Helper method for console development

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

#if defined( _X360 )

void ConVar_PublishToVXConsole();

#endif

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

// Called when a ConCommand needs to execute

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

typedef void ( *FnCommandCallbackV1_t )( void );

typedef void ( *FnCommandCallback_t )( const CCommandContext &context, const CCommand &command );

#define COMMAND_COMPLETION_MAXITEMS		64

#define COMMAND_COMPLETION_ITEM_LENGTH	64

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

// Returns 0 to COMMAND_COMPLETION_MAXITEMS worth of completion strings

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

typedef int  ( *FnCommandCompletionCallback )( const char *partial, char commands[ COMMAND_COMPLETION_MAXITEMS ][ COMMAND_COMPLETION_ITEM_LENGTH ] );

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

// Interface version

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

class ICommandCallback

{

public:

	virtual void CommandCallback( const CCommand &command ) = 0;

};

class ICommandCallback2

{

public:

	virtual void CommandCallback( const CCommandContext &context, const CCommand &command ) = 0;

};

class ICommandCompletionCallback

{

public:

	virtual int  CommandCompletionCallback( const char *pPartial, CUtlVector< CUtlString > &commands ) = 0;

};

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

// Purpose: The base console invoked command/cvar interface

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

class ConCommandBase

{

	friend class CCvar;

	friend class ConVar;

	friend class ConCommand;

	friend void ConVar_Register( int nCVarFlag, IConCommandBaseAccessor *pAccessor );

	friend void ConVar_PublishToVXConsole();

	// FIXME: Remove when ConVar changes are done

	friend class CDefaultCvar;

public:

								ConCommandBase( void );

								ConCommandBase( const char *pName, const char *pHelpString = 0, 

									int flags = 0 );

	virtual						~ConCommandBase( void );

	virtual	bool				IsCommand( void ) const;

	// Check flag

	virtual bool				IsFlagSet( int flag ) const;

	// Set flag

	virtual void				AddFlags( int flags );

	// Clear flag

	virtual void				RemoveFlags( int flags );

	virtual int					GetFlags() const;

	// Return name of cvar

	virtual const char			*GetName( void ) const;

	// Return help text for cvar

	virtual const char			*GetHelpText( void ) const;

	// Deal with next pointer

	const ConCommandBase		*GetNext( void ) const;

	ConCommandBase				*GetNext( void );

	virtual bool				IsRegistered( void ) const;

	// Returns the DLL identifier

	virtual CVarDLLIdentifier_t	GetDLLIdentifier() const;

protected:

	virtual void				Create( const char *pName, const char *pHelpString = 0, 

									int flags = 0 );

	// Used internally by OneTimeInit to initialize/shutdown

	virtual void				Init();

	void						Shutdown();

	// Internal copy routine ( uses new operator from correct module )

	char						*CopyString( const char *from );

private:

	// Next ConVar in chain

	// Prior to register, it points to the next convar in the DLL.

	// Once registered, though, m_pNext is reset to point to the next

	// convar in the global list

	ConCommandBase				*m_pNext;

	// Has the cvar been added to the global list?

	bool						m_bRegistered;

	// Static data

	const char 					*m_pszName;

	const char 					*m_pszHelpString;

	// ConVar flags

	int							m_nFlags;

protected:

	// ConVars add themselves to this list for the executable. 

	// Then ConVar_Register runs through  all the console variables 

	// and registers them into a global list stored in vstdlib.dll

	static ConCommandBase		*s_pConCommandBases;

	// ConVars in this executable use this 'global' to access values.

	static IConCommandBaseAccessor	*s_pAccessor;

public:

	inline void SetFlags(int flags)	

	{ 

		m_nFlags = flags; 

	}

};

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

// Command tokenizer

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

class CCommand

{

public:

	CCommand();

	CCommand( int nArgC, const char **ppArgV );

	bool Tokenize( const char *pCommand, characterset_t *pBreakSet = NULL );

	void Reset();

	int ArgC() const;

	const char **ArgV() const;

	const char *ArgS() const;					// All args that occur after the 0th arg, in string form

	const char *GetCommandString() const;		// The entire command in string form, including the 0th arg

	const char *operator[]( int nIndex ) const;	// Gets at arguments

	const char *Arg( int nIndex ) const;		// Gets at arguments

	// Helper functions to parse arguments to commands.

	const char* FindArg( const char *pName ) const;

	int FindArgInt( const char *pName, int nDefaultVal ) const;

	static int MaxCommandLength();

	static characterset_t* DefaultBreakSet();

private:

	enum

	{

		COMMAND_MAX_ARGC = 64,

		COMMAND_MAX_LENGTH = 512,

	};

	int		m_nArgc;

	int		m_nArgv0Size;

	char	m_pArgSBuffer[ COMMAND_MAX_LENGTH ];

	char	m_pArgvBuffer[ COMMAND_MAX_LENGTH ];

	const char*	m_ppArgv[ COMMAND_MAX_ARGC ];

};

inline int CCommand::MaxCommandLength()

{

	return COMMAND_MAX_LENGTH - 1;

}

inline int CCommand::ArgC() const

{

	return m_nArgc;

}

inline const char **CCommand::ArgV() const

{

	return m_nArgc ? (const char**)m_ppArgv : NULL;

}

inline const char *CCommand::ArgS() const

{

	return m_nArgv0Size ? &m_pArgSBuffer[m_nArgv0Size] : "";

}

inline const char *CCommand::GetCommandString() const

{

	return m_nArgc ? m_pArgSBuffer : "";

}

inline const char *CCommand::Arg( int nIndex ) const

{

	// FIXME: Many command handlers appear to not be particularly careful

	// about checking for valid argc range. For now, we're going to

	// do the extra check and return an empty string if it's out of range

	if ( nIndex < 0 || nIndex >= m_nArgc )

		return "";

	return m_ppArgv[nIndex];

}

inline const char *CCommand::operator[]( int nIndex ) const

{

	return Arg( nIndex );

}

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

// Purpose: The console invoked command

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

class ConCommand : public ConCommandBase

{

friend class CCvar;

public:

	typedef ConCommandBase BaseClass;

	ConCommand( const char *pName, FnCommandCallbackV1_t callback, 

		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

	ConCommand( const char *pName, FnCommandCallback_t callback, 

		const char *pHelpString = 0, int flags = 0, FnCommandCompletionCallback completionFunc = 0 );

	ConCommand( const char *pName, ICommandCallback *pCallback, 

		const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );

	ConCommand( const char *pName, ICommandCallback2 *pCallback, 

		const char *pHelpString = 0, int flags = 0, ICommandCompletionCallback *pCommandCompletionCallback = 0 );

	virtual ~ConCommand( void );

	virtual	bool IsCommand( void ) const;

	virtual int AutoCompleteSuggest( const char *partial, CUtlVector< CUtlString > &commands );

	virtual bool CanAutoComplete( void );

	// Invoke the function

	virtual void Dispatch( const CCommandContext &context, const CCommand &command );

private:

	// NOTE: To maintain backward compat, we have to be very careful:

	// All public virtual methods must appear in the same order always

	// since engine code will be calling into this code, which *does not match*

	// in the mod code; it's using slightly different, but compatible versions

	// of this class. Also: Be very careful about adding new fields to this class.

	// Those fields will not exist in the version of this class that is instanced

	// in mod code.

	// Call this function when executing the command

	union

	{

		FnCommandCallbackV1_t m_fnCommandCallbackV1;

		FnCommandCallback_t m_fnCommandCallback;

		ICommandCallback *m_pCommandCallback; 

		ICommandCallback2 *m_pCommandCallback2; 

	};

	union

	{

		FnCommandCompletionCallback	m_fnCompletionCallback;

		ICommandCompletionCallback *m_pCommandCompletionCallback;

	};

	bool m_bHasCompletionCallback : 1;

	bool m_bUsingNewCommandCallback : 1;

	bool m_bUsingCommandCallbackInterface : 1;

	bool m_bUsingCommandCallbackInterface2 : 1;

public:

	inline FnCommandCallback_t GetCallback() const

	{ 

		return m_fnCommandCallback; 

	}

};

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

// Purpose: A console variable

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

class ConVar : public ConCommandBase, public IConVar

{

friend class CCvar;

friend class ConVarRef;

friend class SplitScreenConVarRef;

public:

	typedef ConCommandBase BaseClass;

								ConVar( const char *pName, const char *pDefaultValue, int flags = 0);

								ConVar( const char *pName, const char *pDefaultValue, int flags, 

									const char *pHelpString );

								ConVar( const char *pName, const char *pDefaultValue, int flags, 

									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax );

								ConVar( const char *pName, const char *pDefaultValue, int flags, 

									const char *pHelpString, FnChangeCallback_t callback );

								ConVar( const char *pName, const char *pDefaultValue, int flags, 

									const char *pHelpString, bool bMin, float fMin, bool bMax, float fMax,

									FnChangeCallback_t callback );

	virtual						~ConVar( void );

	virtual bool				IsFlagSet( int flag ) const;

	virtual const char*			GetHelpText( void ) const;

	virtual bool				IsRegistered( void ) const;

	virtual const char			*GetName( void ) const;

	// Return name of command (usually == GetName(), except in case of FCVAR_SS_ADDED vars

	virtual const char			*GetBaseName( void ) const;

	virtual int					GetSplitScreenPlayerSlot() const;

	virtual void				AddFlags( int flags );

	virtual int					GetFlags() const;

	virtual	bool				IsCommand( void ) const;

	// Install a change callback (there shouldn't already be one....)

	void InstallChangeCallback( FnChangeCallback_t callback, bool bInvoke = true );

	void RemoveChangeCallback( FnChangeCallback_t callbackToRemove );

	int GetChangeCallbackCount() const { return m_pParent->m_fnChangeCallbacks.Count(); }

	FnChangeCallback_t GetChangeCallback( int slot ) const { return m_pParent->m_fnChangeCallbacks[ slot ]; }

	// Retrieve value

	FORCEINLINE_CVAR float			GetFloat( void ) const;

	FORCEINLINE_CVAR int			GetInt( void ) const;

	FORCEINLINE_CVAR Color			GetColor( void ) const;

	FORCEINLINE_CVAR bool			GetBool() const {  return !!GetInt(); }

	FORCEINLINE_CVAR char const	   *GetString( void ) const;

	// Compiler driven selection for template use

	template <typename T> T Get( void ) const;

	template <typename T> T Get( T * ) const;

	// Any function that allocates/frees memory needs to be virtual or else you'll have crashes

	//  from alloc/free across dll/exe boundaries.

	// These just call into the IConCommandBaseAccessor to check flags and set the var (which ends up calling InternalSetValue).

	virtual void				SetValue( const char *value );

	virtual void				SetValue( float value );

	virtual void				SetValue( int value );

	virtual void				SetValue( Color value );

	// Reset to default value

	void						Revert( void );

	// True if it has a min/max setting

	bool						HasMin() const;

	bool						HasMax() const;

	bool						GetMin( float& minVal ) const;

	bool						GetMax( float& maxVal ) const;

	float						GetMinValue() const;

	float						GetMaxValue() const;

	const char					*GetDefault( void ) const;

	// Value

	struct CVValue_t

	{

		char						*m_pszString;

		int							m_StringLength;

		// Values

		float						m_fValue;

		int							m_nValue;

	};

	FORCEINLINE_CVAR CVValue_t &GetRawValue()

	{

		return m_Value;

	}

	FORCEINLINE_CVAR const CVValue_t &GetRawValue() const

	{

		return m_Value;

	}

private:

	bool						InternalSetColorFromString( const char *value );

	// Called by CCvar when the value of a var is changing.

	virtual void				InternalSetValue(const char *value);

	// For CVARs marked FCVAR_NEVER_AS_STRING

	virtual void				InternalSetFloatValue( float fNewValue );

	virtual void				InternalSetIntValue( int nValue );

	virtual void				InternalSetColorValue( Color value );

	virtual bool				ClampValue( float& value );

	virtual void				ChangeStringValue( const char *tempVal, float flOldValue );

	virtual void				Create( const char *pName, const char *pDefaultValue, int flags = 0,

									const char *pHelpString = 0, bool bMin = false, float fMin = 0.0,

									bool bMax = false, float fMax = false, FnChangeCallback_t callback = 0 );

	// Used internally by OneTimeInit to initialize.

	virtual void				Init();

protected:

	// This either points to "this" or it points to the original declaration of a ConVar.

	// This allows ConVars to exist in separate modules, and they all use the first one to be declared.

	// m_pParent->m_pParent must equal m_pParent (ie: m_pParent must be the root, or original, ConVar).

	ConVar						*m_pParent;

	// Static data

	const char					*m_pszDefaultValue;

	CVValue_t					m_Value;

	// Min/Max values

	bool						m_bHasMin;

	float						m_fMinVal;

	bool						m_bHasMax;

	float						m_fMaxVal;

	// Call this function when ConVar changes

	CUtlVector< FnChangeCallback_t > m_fnChangeCallbacks;

public:

	inline void SetMin(bool set, float min=0.0)

	{ 

		m_bHasMin = set; 

		m_fMinVal = min; 

	}

	inline void SetMax(bool set, float max=0.0)

	{

		m_bHasMax = set;

		m_fMaxVal = max; 

	}

};

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

// Purpose: Return ConVar value as a float

// Output : float

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

FORCEINLINE_CVAR float ConVar::GetFloat( void ) const

{

#ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

#endif

	return m_pParent->m_Value.m_fValue;

}

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

// Purpose: Return ConVar value as an int

// Output : int

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

FORCEINLINE_CVAR int ConVar::GetInt( void ) const 

{

#ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

#endif

	return m_pParent->m_Value.m_nValue;

}

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

// Purpose: Return ConVar value as a color

// Output : Color

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

FORCEINLINE_CVAR Color ConVar::GetColor( void ) const 

{

#ifdef CONVAR_TEST_MATERIAL_THREAD_CONVARS

	Assert( ThreadInMainThread() || IsFlagSet( FCVAR_MATERIAL_THREAD_MASK | FCVAR_ACCESSIBLE_FROM_THREADS ) );

#endif

	unsigned char *pColorElement = ((unsigned char *)&m_pParent->m_Value.m_nValue);

	return Color( pColorElement[0], pColorElement[1], pColorElement[2], pColorElement[3] );

}

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

template <> FORCEINLINE_CVAR float			ConVar::Get<float>( void ) const		{ return GetFloat(); }

template <> FORCEINLINE_CVAR int			ConVar::Get<int>( void ) const			{ return GetInt(); }

template <> FORCEINLINE_CVAR bool			ConVar::Get<bool>( void ) const			{ return GetBool(); }

template <> FORCEINLINE_CVAR const char *	ConVar::Get<const char *>( void ) const	{ return GetString(); }

template <> FORCEINLINE_CVAR float			ConVar::Get<float>( float *p ) const				{ return ( *p = GetFloat() ); }

template <> FORCEINLINE_CVAR int			ConVar::Get<int>( int *p ) const					{ return ( *p = GetInt() ); }

template <> FORCEINLINE_CVAR bool			ConVar::Get<bool>( bool *p ) const					{ return ( *p = GetBool() ); }

template <> FORCEINLINE_CVAR const char *	ConVar::Get<const char *>( char const **p ) const	{ return ( *p = GetString() ); }

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

// Purpose: Return ConVar value as a string, return "" for bogus string pointer, etc.