#ifndef CONSOLE_H
#define CONSOLE_H

#include "tier2/iappsystem.h"
#include "tier0/platform.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "tier1/interface.h"

class ConVar;
class ConCommand;


typedef void(*ConCommandFn)(int argc, char **argv);

abstract_class IConsole: public IAppSystem
{
public:
	// Variables
	virtual void RegisterVar( ConVar *cvar ) = 0;
	virtual void UnRegisterVar( ConVar *cvar ) = 0;
	virtual ConVar *FindVar( const char *pName ) = 0;

	// Commands
	virtual void RegisterCommand( ConCommand *cvar ) = 0;
	virtual void UnRegisterCommand( ConCommand *cvar ) = 0;
	virtual ConCommand *FindCommand( const char *pName ) = 0;

	// Command buffer 
	virtual void Execute( void ) = 0;
	virtual void ExecuteArguments( CUtlVector<CUtlString> &args ) = 0;
	virtual CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz ) = 0;

	virtual void AddCommand( const char *psz ) = 0;
	virtual void InsertCommand( const char *psz ) = 0;
};

IConsole *Console();
#define CONSOLE_INTERFACE_VERSION "Console001"


#define FCVAR_NONE 0
#define FCVAR_DEVELOPMENTONLY 0x1
#define FCVAR_GAMEDLL 0x2
#define FCVAR_CLIENTDLL 0x4
#define FCVAR_HIDDEN 0x8

#define FCVAR_PROTECTED 0x10
#define FCVAR_SPONLY 0x20
#define FCVAR_ARCHIVE 0x40
#define FCVAR_NOTIFY 0x80
#define FCVAR_CHEAT 0x100
#define FCVAR_REPLICATED 0x200

class ConVar
{
public:
	ConVar( const char *pName, const char *pDefaultValue, int flags );
	ConVar( const char *pName, const char *pDefaultValue, int flags,
		const char *pHelpString );
	ConVar( const char *pName, const char *pDefaultValue, int flags,
		const char *pHelpString, ConCommandFn callback );
	
	bool IsFlagSet( int flag );
	const char *GetHelpText( void );
	bool IsRegistered( void );
	const char *GetName( void );
	void AddFlags( int flags );
	bool IsCommand( void );

	void InstallChangeCallback( ConCommandFn );

	float GetFloat( void );
	int GetInt( void );
	bool GetBool( void );
	const char *GetString( void );

	void SetValue( const char *szValue );
	void SetValue( float fValue );
	void SetValue( int iValue );
private:
	CUtlString m_szName;
	CUtlString m_szHelpString;
	CUtlString m_szDefaultValue;

	CUtlString m_szValue;
	float m_fValue;
	int m_nValue;

	int m_flags;
};

inline ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags ) 
	: ConVar(pName, pDefaultValue, flags, 0)
{
		
}
inline ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
	const char *pHelpString ) 
	: ConVar(pName, pDefaultValue, flags, pHelpString, 0)
{
}
inline ConVar::ConVar( const char *pName, const char *pDefaultValue, int flags,
	const char *pHelpString, ConCommandFn callback )
{
	m_szName = pName;
	m_flags = flags;
	SetValue(pDefaultValue);
}

inline bool ConVar::IsFlagSet( int flag )
{
	return (m_flags & flag) > 0;
}
inline const char *ConVar::GetHelpText( void )
{
	return m_szHelpString;
}
inline bool ConVar::IsRegistered( void )
{

}
inline const char *ConVar::GetName( void )
{
	return m_szName;
}
inline void ConVar::AddFlags( int flags )
{

}
inline bool ConVar::IsCommand( void )
{

}

inline void ConVar::InstallChangeCallback( ConCommandFn )
{

}

inline float ConVar::GetFloat( void )
{
	return m_fValue; 
}
inline int ConVar::GetInt( void )
{
	return m_nValue; 
}
inline bool ConVar::GetBool( void )
{
	return m_nValue;
}
inline const char *ConVar::GetString( void ) 
{

}

inline void ConVar::SetValue( const char *szValue )
{
	if (!szValue)
		return;
	m_szValue = szValue;
	m_fValue = V_atof(szValue);
	m_nValue = V_atoi(szValue);
}
inline void ConVar::SetValue( float fValue )
{
	m_fValue = fValue;
	m_nValue = fValue;
	m_szValue = CUtlString("%f\n",fValue);
}
inline void ConVar::SetValue( int iValue )
{
	m_fValue = iValue;
	m_nValue = iValue;
	m_szValue = CUtlString("%i\n",iValue);
}


class ConCommand
{
public:
	ConCommand(const char *pName, ConCommandFn callback, 
		const char *pHelpString=0, int flags=0);
	
	const char *GetName( void );
	const char *GetHelpText( void );
	ConCommandFn GetCallback( void );
private:
	CUtlString m_szName;
	CUtlString m_szHelpString = NULL;
	ConCommandFn m_callback;

	int m_flags;
};

inline ConCommand::ConCommand(const char *pName, ConCommandFn callback, 
	const char *pHelpString, int flags)
{
	m_szName = pName;
	m_callback = callback;
	m_flags = flags;
	Console()->RegisterCommand(this);
};

inline const char *ConCommand::GetHelpText( void )
{
	return m_szHelpString;
}

inline const char *ConCommand::GetName( void )
{
	return m_szName;
}

inline ConCommandFn ConCommand::GetCallback( void )
{
	return m_callback;
}

#endif