//=======================================================================
//			Copyright XashXT Group 2007 ©
//		    cmd.c - script command processing module
//=======================================================================

#include "launch.h"

#define MAX_CMD_BUFFER	16384
#define MAX_CMD_LINE	1024

typedef struct
{
	byte		*data;
	int		maxsize;
	int		cursize;
} cmd_t;

int	cmd_wait;
cmd_t	cmd_text;
byte	cmd_text_buf[MAX_CMD_BUFFER];

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

			COMMAND BUFFER

=============================================================================
*/
/*
============
Cbuf_Init
============
*/
void Cbuf_Init( void )
{
	cmd_text.data = cmd_text_buf;
	cmd_text.maxsize = MAX_CMD_BUFFER;
	cmd_text.cursize = 0;
}

/*
============
Cbuf_AddText

Adds command text at the end of the buffer
============
*/
void Cbuf_AddText( const char *text )
{
	int	l;

	l = com.strlen( text );
	if( cmd_text.cursize + l >= cmd_text.maxsize )
	{
		MsgDev( D_WARN, "Cbuf_AddText: overflow\n" );
		return;
	}
	Mem_Copy( &cmd_text.data[cmd_text.cursize], text, l );
	cmd_text.cursize += l;
}


/*
============
Cbuf_InsertText

Adds command text immediately after the current command
Adds a \n to the text
============
*/
void Cbuf_InsertText( const char *text )
{
	int	i, len;

	len = com.strlen( text ) + 1;
	if( len + cmd_text.cursize > cmd_text.maxsize )
	{
		MsgDev( D_WARN, "Cbuf_InsertText overflowed\n" );
		return;
	}

	// move the existing command text
	for( i = cmd_text.cursize - 1; i >= 0; i-- )
	{
		cmd_text.data[i + len] = cmd_text.data[i];
	}

	// copy the new text in
	Mem_Copy( cmd_text.data, (char *)text, len - 1 );
	cmd_text.data[len - 1] = '\n'; // add a \n
	cmd_text.cursize += len;
}

/*
============
Cbuf_ExecuteText
============
*/
void Cbuf_ExecuteText( int exec_when, const char *text )
{
	switch( exec_when )
	{
	case EXEC_NOW:
		if( text && com.strlen( text ))
			Cmd_ExecuteString( text );
		else Cbuf_Execute();
		break;
	case EXEC_INSERT:
		Cbuf_InsertText( text );
		break;
	case EXEC_APPEND:
		Cbuf_AddText( text );
		break;
	default:
		MsgDev( D_ERROR, "Cbuf_ExecuteText: bad execute target\n" );
		break;
	}
}

/*
============
Cbuf_Execute
============
*/
void Cbuf_Execute( void )
{
	char	*text;
	char	line[MAX_CMD_LINE];
	int	i, quotes;

	while( cmd_text.cursize )
	{
		if( cmd_wait )
		{
			// skip out while text still remains in buffer, leaving it for next frame
			cmd_wait--;
			break;
		}

		// find a \n or ; line break
		text = (char *)cmd_text.data;

		quotes = 0;
		for( i = 0; i < cmd_text.cursize; i++ )
		{
			if( text[i] == '"') quotes++;
			if(!( quotes & 1 ) &&  text[i] == ';' )
				break; // don't break if inside a quoted string
			if( text[i] == '\n' || text[i] == '\r' ) break;
		}

		if( i >= MAX_CMD_LINE - 1 )
			Sys_Error( "Cbuf_Execute: command string owerflow\n" );

		Mem_Copy( line, text, i );
		line[i] = 0;

		// delete the text from the command buffer and move remaining commands down
		// this is necessary because commands (exec) can insert data at the
		// beginning of the text buffer

		if( i == cmd_text.cursize )
		{
			cmd_text.cursize = 0;
		}
		else
		{
			i++;
			cmd_text.cursize -= i;
			memmove( text, text + i, cmd_text.cursize );
		}

		// execute the command line
		Cmd_ExecuteString( line );		
	}
}
/*
==============================================================================

						SCRIPT COMMANDS

==============================================================================
*/
/*
===============
Cmd_StuffCmds_f

Adds command line parameters as script statements
Commands lead with a +, and continue until a - or another +
xash +prog jctest.qp +cmd amlev1
xash -nosound +cmd amlev1
===============
*/
void Cmd_StuffCmds_f( void )
{
	int	i, j, l = 0;
	char	build[MAX_SYSPATH]; // this is for all commandline options combined (and is bounds checked)

	if( Cmd_Argc() != 1 )
	{
		Msg( "Usage: stuffcmds : execute command line parameters\n" );
		return;
	}

	// no reason to run the commandline arguments twice
	if( Sys.stuffcmdsrun ) return;

	Sys.stuffcmdsrun = true;
	build[0] = 0;

	for( i = 0; i < fs_argc; i++ )
	{
		if( fs_argv[i] && fs_argv[i][0] == '+' && ( fs_argv[i][1] < '0' || fs_argv[i][1] > '9' ) && l + com.strlen( fs_argv[i] ) - 1 <= sizeof( build ) - 1 )
		{
			j = 1;

			while( fs_argv[i][j] )
				build[l++] = fs_argv[i][j++];

			for( i++; i < fs_argc; i++ )
			{
				if( !fs_argv[i] ) continue;
				if(( fs_argv[i][0] == '+' || fs_argv[i][0] == '-' ) && ( fs_argv[i][1] < '0' || fs_argv[i][1] > '9' ))
					break;
				if( l + com.strlen( fs_argv[i]) + 4 > sizeof( build ) - 1 )
					break;
				build[l++] = ' ';
	
				if( com.strchr( fs_argv[i], ' ' ))
					build[l++] = '\"';
	
				for( j = 0; fs_argv[i][j]; j++ )
					build[l++] = fs_argv[i][j];
	
				if( com.strchr( fs_argv[i], ' ' ))
					build[l++] = '\"';
			}
			build[l++] = '\n';
			i--;
		}
	}

	// now terminate the combined string and prepend it to the command buffer
	// we already reserved space for the terminator
	build[l++] = 0;
	Cbuf_InsertText( build );
}

/*
============
Cmd_Wait_f

Causes execution of the remainder of the command buffer to be delayed until
next frame.  This allows commands like:
bind g "cmd use rocket ; +attack ; wait ; -attack ; cmd use blaster"
============
*/
void Cmd_Wait_f( void )
{
	if( Cmd_Argc() == 1 ) cmd_wait = 1;
	else cmd_wait = com.atoi( Cmd_Argv( 1 ));
	
}

/*
===============
Cmd_Exec_f
===============
*/
void Cmd_Exec_f( void )
{
	string	cfgpath;
	size_t	len;
	char	*f; 

	if( Cmd_Argc() != 2 )
	{
		Msg( "Usage: exec <filename>\n" );
		return;
	}

	com.strncpy( cfgpath, Cmd_Argv( 1 ), sizeof( cfgpath )); 
	FS_DefaultExtension( cfgpath, ".cfg" ); // append as default

	f = FS_LoadFile( cfgpath, &len );
	if( !f )
	{
		MsgDev( D_NOTE, "couldn't exec %s\n", Cmd_Argv( 1 ));
		return;
	}

	MsgDev( D_INFO, "execing %s\n", Cmd_Argv( 1 ));
	Cbuf_InsertText( f );
	Mem_Free( f );
}

/*
===============
Cmd_Echo_f

Just prints the rest of the line to the console
===============
*/
void Cmd_Echo_f( void )
{
	int	i;
	
	for(i = 1; i < Cmd_Argc(); i++)
		Msg("%s ",Cmd_Argv(i));
	Msg ("\n");
}

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

					COMMAND EXECUTION

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

#define CMD_EXTDLL		BIT( 0 )

typedef struct cmd_function_s
{
	struct cmd_function_s	*next;
	char			*name;
	char			*desc;
	xcommand_t		function;
	int			flags;
} cmd_function_t;

static int		cmd_argc;
static char		*cmd_argv[MAX_CMD_TOKENS];
static char		cmd_tokenized[MAX_CMD_BUFFER];	// will have 0 bytes inserted
static cmd_function_t	*cmd_functions;			// possible commands to execute

/*
============
Cmd_Argc
============
*/
uint Cmd_Argc( void )
{
	return cmd_argc;
}

/*
============
Cmd_Argv
============
*/
char *Cmd_Argv( uint arg )
{
	if( arg >= cmd_argc )
		return "";
	return cmd_argv[arg];	
}

/*
============
Cmd_Args

Returns a single string containing argv(1) to argv(argc()-1)
============
*/
char *Cmd_Args( void )
{
	static char	cmd_args[MAX_SYSPATH];
	int		i;

	cmd_args[0] = 0;
	// build only for current call
	for( i = 1; i < cmd_argc; i++ )
	{
		com.strcat( cmd_args, cmd_argv[i] );
		if( i != cmd_argc - 1 ) com.strcat( cmd_args, " " );
	}
	return cmd_args;
}

/*
============
Cmd_TokenizeString

Parses the given string into command line tokens.
The text is copied to a seperate buffer and 0 characters
are inserted in the apropriate place, The argv array
will point into this temporary buffer.
============
*/
void Cmd_TokenizeString( const char *text_in )
{
	const char	*text;
	char		*textOut;

	cmd_argc = 0; // clear previous args
	if( !text_in ) return;

	text = text_in;
	textOut = cmd_tokenized;

	while( 1 )
	{
		// this is usually something malicious
		if( cmd_argc == MAX_CMD_TOKENS ) return;

		while( 1 )
		{
			// skip whitespace
			while( *text && *text <= ' ' ) text++;
			if( !*text ) return; // all tokens parsed

			// skip // comments
			if( text[0] == '/' && text[1] == '/' ) return; // all tokens parsed

			// skip /* */ comments
			if( text[0] == '/' && text[1] =='*' )
			{
				while( *text && ( text[0] != '*' || text[1] != '/' )) text++;
				if( !*text ) return; // all tokens parsed
				text += 2;
			}
			else break; // we are ready to parse a token
		}

		// handle quoted strings
		if( *text == '"' )
		{
			cmd_argv[cmd_argc] = textOut;
			cmd_argc++;
			text++;
			while( *text && *text != '"' )
				*textOut++ = *text++;
			*textOut++ = 0;
			if( !*text ) return; // all tokens parsed
			text++;
			continue;
		}

		// regular token
		cmd_argv[cmd_argc] = textOut;
		cmd_argc++;

		// skip until whitespace, quote, or command
		while( *text > ' ' )
		{
			if( text[0] == '"' ) break;
			if( text[0] == '/' && text[1] == '/' ) break;
			// skip /* */ comments
			if( text[0] == '/' && text[1] =='*' ) break;

			*textOut++ = *text++;
		}
		*textOut++ = 0;
		if( !*text ) return; // all tokens parsed
	}
	
}


/*
============
Cmd_AddCommand
============
*/
void Cmd_AddCommand( const char *cmd_name, xcommand_t function, const char *cmd_desc )
{
	cmd_function_t	*cmd;
	
	// fail if the command already exists
	if( Cmd_Exists( cmd_name ))
	{
		MsgDev(D_INFO, "Cmd_AddCommand: %s already defined\n", cmd_name);
		return;
	}

	// use a small malloc to avoid zone fragmentation
	cmd = Malloc( sizeof( cmd_function_t ));
	cmd->name = copystring( cmd_name );
	cmd->desc = copystring( cmd_desc );
	cmd->function = function;
	cmd->next = cmd_functions;
	cmd_functions = cmd;
}

/*
============
Cmd_AddGameCommand
============
*/
void Cmd_AddGameCommand( const char *cmd_name, xcommand_t function )
{
	cmd_function_t	*cmd;
	
	// fail if the command already exists
	if( Cmd_Exists( cmd_name ))
	{
		MsgDev(D_INFO, "Cmd_AddCommand: %s already defined\n", cmd_name);
		return;
	}

	// use a small malloc to avoid zone fragmentation
	cmd = Malloc( sizeof( cmd_function_t ));
	cmd->name = copystring( cmd_name );
	cmd->function = function;
	cmd->flags = CMD_EXTDLL;
	cmd->next = cmd_functions;
	cmd_functions = cmd;
}

/*
============
Cmd_RemoveCommand
============
*/
void Cmd_RemoveCommand (const char *cmd_name)
{
	cmd_function_t	*cmd, **back;

	back = &cmd_functions;
	while( 1 )
	{
		cmd = *back;
		if (!cmd ) return;
		if (!strcmp( cmd_name, cmd->name ))
		{
			*back = cmd->next;
			if(cmd->name) Mem_Free(cmd->name);
			if(cmd->desc) Mem_Free(cmd->desc);
			Mem_Free(cmd);
			return;
		}
		back = &cmd->next;
	}
}

/*
============
Cmd_LookupCmds
============
*/
void Cmd_LookupCmds( char *buffer, void *ptr, setpair_t callback )
{
	cmd_function_t	*cmd;

	// nothing to process ?
	if( !callback ) return;
	
	for( cmd = cmd_functions; cmd; cmd = cmd->next )
	{
		if( !buffer ) callback( cmd->name, (char *)cmd->function, cmd->desc, ptr );
		else callback( cmd->name, (char *)cmd->function, buffer, ptr );
	}
}

/*
============
Cmd_Exists
============
*/
bool Cmd_Exists( const char *cmd_name )
{
	cmd_function_t	*cmd;

	for( cmd = cmd_functions; cmd; cmd = cmd->next )
	{
		if( !com.strcmp( cmd_name, cmd->name ))
			return true;
	}
	return false;
}

/*
============
Cmd_ExecuteString

A complete command line has been parsed, so try to execute it
============
*/
void Cmd_ExecuteString( const char *text )
{	
	cmd_function_t	*cmd, **prev;

	// execute the command line
	Cmd_TokenizeString( text );		
	if( !Cmd_Argc()) return; // no tokens

	// check registered command functions	
	for( prev = &cmd_functions; *prev; prev = &cmd->next )
	{
		cmd = *prev;
		if( !com.stricmp( cmd_argv[0], cmd->name ))
		{
			// rearrange the links so that the command will be
			// near the head of the list next time it is used
			*prev = cmd->next;
			cmd->next = cmd_functions;
			cmd_functions = cmd;

			// perform the action
			if( !cmd->function )
				Cmd_ExecuteString( va( "cmd %s", text ));
			else cmd->function();
			return;
		}
	}
	
	// check cvars
	if( Cvar_Command()) return;

	if( Sys.app_name == HOST_NORMAL && Sys.CmdFwd )
	{
		// all unrecognized commands will be forwarded to a server
		Sys.CmdFwd();
	}
	else Msg( "Unknown command \"%s\"\n", text );
}

/*
============
Cmd_List_f
============
*/
void Cmd_List_f( void )
{
	cmd_function_t	*cmd;
	int		i = 0;
	char		*match;

	if( Cmd_Argc() > 1 ) match = Cmd_Argv( 1 );
	else match = NULL;

	for( cmd = cmd_functions; cmd; cmd = cmd->next )
	{
		if( match && !com.stricmpext( match, cmd->name ))
			continue;
		Msg( "%s\n", cmd->name );
		i++;
	}
	Msg( "%i commands\n", i );
}

/*
============
Cmd_Unlink

unlink all commands with flag CVAR_EXTDLL
============
*/
void Cmd_Unlink( void )
{
	cmd_function_t	*cmd;
	cmd_function_t	**prev;
	int		count = 0;

	if( Cvar_VariableInteger( "host_gameloaded" ))
	{
		Msg( "can't unlink cvars while game is loaded\n" );
		return;
	}

	// unlink commands first
	Cmd_Unlink ();

	prev = &cmd_functions;
	while( 1 )
	{
		cmd = *prev;
		if( !cmd ) break;

		if( !( cmd->flags & CMD_EXTDLL ))
		{
			prev = &cmd->next;
			continue;
		}

		*prev = cmd->next;
		if( cmd->name ) Mem_Free( cmd->name );
		if( cmd->desc ) Mem_Free( cmd->desc );
		Mem_Free( cmd );
		count++;
	}
}

/*
============
Cmd_Init
============
*/
void Cmd_Init( void )
{
	Cbuf_Init();
	cmd_functions = NULL;

	// register our commands
	Cmd_AddCommand ("exec", Cmd_Exec_f, "execute a script file" );
	Cmd_AddCommand ("echo", Cmd_Echo_f, "print a message to the console (useful in scripts)" );
	Cmd_AddCommand ("wait", Cmd_Wait_f, "make script execution wait for some rendered frames" );
	Cmd_AddCommand ("cmdlist", Cmd_List_f, "display all console commands beginning with the specified prefix" );
	Cmd_AddCommand ("stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in valve.rc script)" );

	Memory_Init_Commands(); // memlib stats
}