#include "common.h"

#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>

#include "config.h"
#include "command.h"
#include "xmalloc.h"
#include "debug.h"
#include "env.h"
#include "cli_readline.h"
#include "con-utils.h"
#include "cli.h"

#define DEBUG_PARSER	0	/* set to 1 to debug */

#define debug_parser(fmt, args...)		\
	debug_cond(DEBUG_PARSER, fmt, ##args)

static int cli_parse_line(char *line, char *argv[])
{
	static const FLASH char delim[] = {" \t"};

	char *ptr;
	uint_fast8_t nargs = 0;

	debug_parser("parse_line: \"%s\"\n", line);

	ptr = strtok_P(line, delim);
	while(nargs < CONFIG_SYS_MAXARGS && ptr != NULL) {
		argv[nargs++] = ptr;
	 	ptr = strtok_P(NULL, delim);
	}

	if (ptr != NULL)
		printf_P(PSTR("** Too many args (max. %d) **\n"), CONFIG_SYS_MAXARGS);

	argv[nargs] = NULL;
	debug_parser("parse_line: nargs=%d\n", nargs);

	return nargs;
}

static
void append_char(uint_fast8_t pass, char **p, char c)
{

	if (pass) {
		**p = c;
	}
	++(*p);
}

static
char *process_macros(char *input, char *output)
{
	char c, prev, *inp, *outp;
	const char *varname = NULL;

	for(uint_fast8_t pass = 0; pass < 2; pass++)
	{
		uint_fast8_t state = 0;		/* 0 = waiting for '$'  */
		/* 1 = waiting for '{' */
		/* 2 = waiting for '}' */
		/* 3 = waiting for ''' */

		if (pass == 0) {
			outp = output;
		} else {
			int outputlen = outp - output;
			outp = xrealloc(output, outputlen);
			output = outp;
		}

		inp = input;
		prev = '\0';		/* previous character   */

		debug_parser("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen(inp),
			     inp);

		while ((c = *inp++) != '\0') {

			if (state != 3) {
				/* remove one level of escape characters */
				if ((c == '\\') && (prev != '\\')) {
					if (*inp == '\0')
						break;
					prev = c;
					c = *inp++;
				}
			}

			switch (state) {
			case 0:	/* Waiting for (unescaped) $    */
				if ((c == '\'') && (prev != '\\')) {
					state = 3;
					break;
				}
				if ((c == '$') && (prev != '\\'))
					state++;
				else
					append_char(pass, &outp, c);
				break;
			case 1:	/* Waiting for {        */
				if (c == '{') {
					state++;
					varname = inp;
				} else {
					state = 0;
					append_char(pass, &outp, '$');
					append_char(pass, &outp, c);
				}
				break;
			case 2:	/* Waiting for }        */
				if (c == '}') {
					/* Terminate variable name */
					*(inp-1) = '\0';
					const char *envval = getenv(varname);
					*(inp-1) = '}';
					/* Copy into the line if it exists */
					if (envval != NULL)
						while (*envval)
							append_char(pass, &outp, *(envval++));
					/* Look for another '$' */
					state = 0;
				}
				break;
			case 3:	/* Waiting for '        */
				if ((c == '\'') && (prev != '\\'))
					state = 0;
				else
					append_char(pass, &outp, c);
				break;
			}
			prev = c;
		}

		append_char(pass, &outp, 0);
	}

	debug_parser("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
		     strlen(output), output);

	return output;
}

/**
 *
 *
 * WARNING:
 *
 * We must create a temporary copy of the command since the command we get
 * may be the result from getenv(), which returns a pointer directly to
 * the environment data, which may change magicly when the command we run
 * creates or modifies environment variables (like "bootp" does).
 *
 *
 * @param cmd
 * @param flag
 * @returns
 *
 */
static int cli_run_command(const char *cmd, int flag)
{
	char *cmdbuf;			/* working copy of cmd		*/
	char *token;			/* start of token in cmdbuf	*/
	char *sep;			/* end of token (separator) in cmdbuf */
	char *finaltoken = NULL;	/* token after macro expansion	*/
	char *str;
	char *argv[CONFIG_SYS_MAXARGS + 1];	/* NULL terminated	*/
	int argc;
	uint_fast8_t inquotes, repeatable = 1;
	int rc = 0;

	debug_parser("[RUN_COMMAND] cmd[%p]=\"%s\"\n",
			cmd, cmd ? cmd : "NULL");

	clear_ctrlc();		/* forget any previous Control C */

	if (!cmd || !*cmd)
		return -1;	/* empty command */

	cmdbuf = strdup(cmd);
	if (!cmdbuf)
		return -1;	/* not enough memory */

	str = cmdbuf;

	/* Process separators and check for invalid
	 * repeatable commands
	 */

	debug_parser("[PROCESS_SEPARATORS] %s\n", cmd);
	while (*str) {
		/*
		 * Find separator, or string end
		 * Allow simple escape of ';' by writing "\;"
		 */
		for (inquotes = 0, sep = str; *sep; sep++) {
			if ((*sep == '\'') &&
			    (*(sep - 1) != '\\'))
				inquotes = !inquotes;

			if (!inquotes &&
			    (*sep == ';' || *sep == '\n') &&	/* separator		*/
			    (sep != str) &&			/* past string start	*/
			    (*(sep - 1) != '\\'))		/* and NOT escaped */
				break;
		}

		/*
		 * Limit the token to data between separators
		 */
		token = str;
		if (*sep) {
			str = sep + 1;	/* start of command for next pass */
			*sep = '\0';
		} else {
			str = sep;	/* no more commands for next pass */
		}
		debug_parser("token: \"%s\"\n", token);

		/* find macros in this token and replace them */
		finaltoken = process_macros(token, finaltoken);

		/* Extract arguments */
		argc = cli_parse_line(finaltoken, argv);
		if (argc == 0) {
			rc = -1;	/* no command at all */
			continue;
		}

		if (cmd_process(flag, argc, argv, &repeatable) != CMD_RET_SUCCESS)
			rc = -1;

		/* Did the user stop this? */
		if (had_ctrlc()) {
			rc = -1;	/* if stopped then not repeatable */
			break;
		}
	}

	free(cmdbuf);
	free(finaltoken);

	return rc ? rc : repeatable;
}

static int cli_run_command_list(const char *cmd)
{
	return (cli_run_command(cmd, 0) < 0);
}

/******************************************************************************/


/*
 * Run a command using the selected parser.
 *
 * @param cmd	Command to run
 * @param flag	Execution flags (CMD_FLAG_...)
 * @return 0 on success, or != 0 on error.
 */
int run_command(const char *cmd, int flag)
{
	/*
	 * cli_run_command can return 0 or 1 for success, so clean up
	 * its result.
	 */
	if (cli_run_command(cmd, flag) == -1)
		return 1;

	return 0;
}

/*
 * Run a command using the selected parser, and check if it is repeatable.
 *
 * @param cmd	Command to run
 * @param flag	Execution flags (CMD_FLAG_...)
 * @return 0 (not repeatable) or 1 (repeatable) on success, -1 on error.
 */
static int run_command_repeatable(const char *cmd, int flag)
{
	return cli_run_command(cmd, flag);
}

int run_command_list(const char *cmd, int len)
{
	(void) len;

	return cli_run_command_list(cmd);
}

/****************************************************************************/


void cli_loop(void)
{
	char *lastcommand = NULL;
	int len;
	int flag;
	int rc = 1;

	for (;;) {
		len = cli_readline(PSTR(CONFIG_SYS_PROMPT));

		flag = 0;	/* assume no special flags for now */
		if (len > 0) {
			free (lastcommand);
			lastcommand = strdup(console_buffer);
		} else if (len == 0)
			flag |= CMD_FLAG_REPEAT;

		if (len == -1)
			my_puts_P(PSTR("<INTERRUPT>\n"));
		else
			rc = run_command_repeatable(lastcommand, flag);

		if (rc <= 0) {
			/* invalid command or not repeatable, forget it */
			free(lastcommand);
			lastcommand = NULL;
		}
	}
}


command_ret_t do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	int i;
	(void) cmdtp;

	if (argc < 2)
		return CMD_RET_USAGE;

	for (i = 1; i < argc; ++i) {
		char *arg;

		arg = getenv(argv[i]);
		if (arg == NULL) {
			printf_P(PSTR("## Error: \"%s\" not defined\n"), argv[i]);
			return CMD_RET_FAILURE;
		}

		if (run_command(arg, flag) != 0)
			return CMD_RET_FAILURE;
	}
	return CMD_RET_SUCCESS;
}