/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2009 Erwan Velu - All Rights Reserved
 *
 *   Permission is hereby granted, free of charge, to any person
 *   obtaining a copy of this software and associated documentation
 *   files (the "Software"), to deal in the Software without
 *   restriction, including without limitation the rights to use,
 *   copy, modify, merge, publish, distribute, sublicense, and/or
 *   sell copies of the Software, and to permit persons to whom
 *   the Software is furnished to do so, subject to the following
 *   conditions:
 *
 *   The above copyright notice and this permission notice shall
 *   be included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 *
 * -----------------------------------------------------------------------
 */

#include <stdlib.h>
#include <string.h>
#include <syslinux/config.h>
#include <getkey.h>
#include <acpi/acpi.h>
#include "hdt-cli.h"
#include "hdt-common.h"

struct cli_mode_descr *list_modes[] = {
    &hdt_mode,
    &dmi_mode,
    &syslinux_mode,
    &pxe_mode,
    &kernel_mode,
    &cpu_mode,
    &pci_mode,
    &vesa_mode,
    &disk_mode,
    &vpd_mode,
    &memory_mode,
    &acpi_mode,
    NULL,
};

/*
 * .aliases = {"q", "quit"} won't work since it is an array of pointers, not an
 * array of variables. There is no easy way around it besides declaring the arrays of
 * strings first.
 */
const char *exit_aliases[] = { "q", "quit" };
const char *help_aliases[] = { "h", "?" };

/* List of aliases */
struct cli_alias hdt_aliases[] = {
    {
     .command = CLI_EXIT,
     .nb_aliases = 2,
     .aliases = exit_aliases,
     },
    {
     .command = CLI_HELP,
     .nb_aliases = 2,
     .aliases = help_aliases,
     },
};

struct cli_mode_descr *current_mode;
int autocomplete_backlog;

struct autocomplete_list {
    char autocomplete_token[MAX_LINE_SIZE];
    struct autocomplete_list *next;
};
struct autocomplete_list *autocomplete_head = NULL;
struct autocomplete_list *autocomplete_tail = NULL;
struct autocomplete_list *autocomplete_last_seen = NULL;

static void autocomplete_add_token_to_list(const char *token)
{
    struct autocomplete_list *new = malloc(sizeof(struct autocomplete_list));

    strlcpy(new->autocomplete_token, token, sizeof(new->autocomplete_token));
    new->next = NULL;
    autocomplete_backlog++;

    if (autocomplete_tail != NULL)
	autocomplete_tail->next = new;
    if (autocomplete_head == NULL)
	autocomplete_head = new;
    autocomplete_tail = new;
}

static void autocomplete_destroy_list(void)
{
    struct autocomplete_list *tmp = NULL;

    while (autocomplete_head != NULL) {
	tmp = autocomplete_head->next;
	free(autocomplete_head);
	autocomplete_head = tmp;
    }
    autocomplete_backlog = 0;
    autocomplete_tail = NULL;
    autocomplete_last_seen = NULL;
}

/**
 * set_mode - set the current mode of the cli
 * @mode:	mode to set
 *
 * Unlike cli_set_mode, this function is not used by the cli directly.
 **/
void set_mode(cli_mode_t mode, struct s_hardware *hardware)
{
    int i = 0;

    switch (mode) {
    case EXIT_MODE:
	hdt_cli.mode = mode;
	break;
    case HDT_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_HDT);
	break;
    case PXE_MODE:
	if (hardware->sv->filesystem != SYSLINUX_FS_PXELINUX) {
	    more_printf("You are not currently using PXELINUX\n");
	    break;
	}
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_PXE);
	break;
    case KERNEL_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_KERNEL);
	break;
    case SYSLINUX_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_SYSLINUX);
	break;
    case VESA_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_VESA);
	break;
    case PCI_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_PCI);
	break;
    case CPU_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_CPU);
	break;
    case DMI_MODE:
	if (!hardware->is_dmi_valid) {
	    more_printf("No valid DMI table found, exiting.\n");
	    break;
	}
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_DMI);
	break;
    case DISK_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_DISK);
	break;
    case VPD_MODE:
	if (!hardware->is_vpd_valid) {
	    more_printf("No valid VPD table found, exiting.\n");
	    break;
	}
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_VPD);
	break;
    case MEMORY_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_MEMORY);
	break;
    case ACPI_MODE:
	hdt_cli.mode = mode;
	snprintf(hdt_cli.prompt, sizeof(hdt_cli.prompt), "%s> ", CLI_ACPI);
	break;
    default:
	/* Invalid mode */
	more_printf("Unknown mode, please choose among:\n");
	while (list_modes[i]) {
	    more_printf("\t%s\n", list_modes[i]->name);
	    i++;
	}
    }

    find_cli_mode_descr(hdt_cli.mode, &current_mode);
    /* There is not cli_mode_descr struct for the exit mode */
    if (current_mode == NULL && hdt_cli.mode != EXIT_MODE) {
	/* Shouldn't get here... */
	more_printf("!!! BUG: Mode '%d' unknown.\n", hdt_cli.mode);
    }
}

/**
 * mode_s_to_mode_t - given a mode string, return the cli_mode_t representation
 **/
cli_mode_t mode_s_to_mode_t(char *name)
{
    int i = 0;

    while (list_modes[i]) {
	if (!strncmp(name, list_modes[i]->name, sizeof(list_modes[i]->name)))
	    break;
	i++;
    }

    if (!list_modes[i])
	return INVALID_MODE;
    else
	return list_modes[i]->mode;
}

/**
 * find_cli_mode_descr - find the cli_mode_descr struct associated to a mode
 * @mode:	mode to look for
 * @mode_found:	store the mode if found, NULL otherwise
 *
 * Given a mode name, return a pointer to the associated cli_mode_descr
 * structure.
 * Note: the current mode name is stored in hdt_cli.mode.
 **/
void find_cli_mode_descr(cli_mode_t mode, struct cli_mode_descr **mode_found)
{
    int i = 0;

    while (list_modes[i] && list_modes[i]->mode != mode)
	i++;

    /* Shouldn't get here... */
    if (!list_modes[i])
	*mode_found = NULL;
    else
	*mode_found = list_modes[i];
}

/**
 * expand_aliases - resolve aliases mapping
 * @line:	command line to parse
 * @command:	first token in the line
 * @module:	second token in the line
 * @argc:	number of arguments
 * @argv:	array of arguments
 *
 * We maintain a small list of static alises to enhance user experience.
 * Only commands can be aliased (first token). Otherwise it can become really hairy...
 **/
static void expand_aliases(char *line __unused, char **command, char **module,
			   int *argc, char **argv)
{
    struct cli_mode_descr *mode;
    int i, j;

    find_cli_mode_descr(mode_s_to_mode_t(*command), &mode);
    if (mode != NULL && *module == NULL) {
	/*
	 * The user specified a mode instead of `set mode...', e.g.
	 * `dmi' instead of `set mode dmi'
	 */

	/* *argv is NULL since *module is NULL */
	*argc = 1;
	*argv = malloc(*argc * sizeof(char *));
	argv[0] = malloc((sizeof(*command) + 1) * sizeof(char));
	strlcpy(argv[0], *command, sizeof(*command) + 1);
	dprintf("CLI DEBUG: ALIAS %s ", *command);

	strlcpy(*command, CLI_SET, sizeof(CLI_SET));	/* set */

	*module = malloc(sizeof(CLI_MODE) * sizeof(char));
	strlcpy(*module, CLI_MODE, sizeof(CLI_MODE));	/* mode */

	dprintf("--> %s %s %s\n", *command, *module, argv[0]);
	goto out;
    }

    /* Simple aliases mapping a single command to another one */
    for (i = 0; i < MAX_ALIASES; i++) {
	for (j = 0; j < hdt_aliases[i].nb_aliases; j++) {
	    if (!strncmp(*command, hdt_aliases[i].aliases[j],
			 sizeof(hdt_aliases[i].aliases[j]))) {
		dprintf("CLI DEBUG: ALIAS %s ", *command);
		strlcpy(*command, hdt_aliases[i].command,
			sizeof(hdt_aliases[i].command) + 1);
		dprintf("--> %s\n", *command);
		goto out;	/* Don't allow chaining aliases */
	    }
	}
    }
    return;

out:
    dprintf("CLI DEBUG: New parameters:\n");
    dprintf("CLI DEBUG: command = %s\n", *command);
    dprintf("CLI DEBUG: module  = %s\n", *module);
    dprintf("CLI DEBUG: argc    = %d\n", *argc);
    for (i = 0; i < *argc; i++)
	dprintf("CLI DEBUG: argv[%d] = %s\n", i, argv[0]);
    return;
}

/**
 * parse_command_line - low level parser for the command line
 * @line:	command line to parse
 * @command:	first token in the line
 * @module:	second token in the line
 * @argc:	number of arguments
 * @argv:	array of arguments
 *
 * The format of the command line is:
 *	<main command> [<module on which to operate> [<args>]]
 *	command is always malloc'ed (even for an empty line)
 **/
static void parse_command_line(char *line, char **command, char **module,
			       int *argc, char **argv)
{
    int argc_iter = 0, args_pos = 0, token_found = 0, token_len = 0;
    int args_len = 0;
    char *pch = NULL, *pch_next = NULL, *tmp_pch_next = NULL;

    *command = NULL;
    *module = NULL;
    *argc = 0;

    pch = line;
    while (pch != NULL) {
	pch_next = strchr(pch + 1, ' ');
	tmp_pch_next = pch_next;

	/*
	 * Skip whitespaces if the user entered
	 * 'set   mode        foo' for 'set mode foo'
	 *  ^   ^
	 *  |___|___ pch
	 *      |___ pch_next <- wrong!
	 *
	 *  We still keep the position into tmp_pch_next to compute
	 *  the lenght of the current token.
	 */
	while (pch_next != NULL && !strncmp(pch_next, CLI_SPACE, 1))
	    pch_next++;

	/* End of line guaranteed to be zeroed */
	if (pch_next == NULL) {
	    token_len = (int)(strchr(pch + 1, '\0') - pch);
	    args_len = token_len;
	} else {
	    token_len = (int)(tmp_pch_next - pch);
	    args_len = (int)(pch_next - pch);
	}

	if (token_found == 0) {
	    /* Main command to execute */
	    *command = malloc((token_len + 1) * sizeof(char));
	    strlcpy(*command, pch, token_len);
	    (*command)[token_len] = '\0';
	    dprintf("CLI DEBUG parse: command = %s\n", *command);
	    args_pos += args_len;
	} else if (token_found == 1) {
	    /* Module */
	    *module = malloc((token_len + 1) * sizeof(char));
	    strlcpy(*module, pch, token_len);
	    (*module)[token_len] = '\0';
	    dprintf("CLI DEBUG parse: module  = %s\n", *module);
	    args_pos += args_len;
	} else
	    (*argc)++;

	token_found++;
	pch = pch_next;
    }
    dprintf("CLI DEBUG parse: argc    = %d\n", *argc);

    /* Skip arguments handling if none is supplied */
    if (!*argc)
	return;

    /* Transform the arguments string into an array */
    *argv = malloc(*argc * sizeof(char *));
    pch = strtok(line + args_pos, CLI_SPACE);
    while (pch != NULL) {
	dprintf("CLI DEBUG parse: argv[%d] = %s\n", argc_iter, pch);
	argv[argc_iter] = malloc(strlen(pch) * sizeof(char));
	strlcpy(argv[argc_iter], pch, strlen(pch));
	argc_iter++;
	pch = strtok(NULL, CLI_SPACE);
	/*
	 * strtok(NULL, CLI_SPACE) over a stream of spaces
	 * will return an empty string
	 */
	while (pch != NULL && !strncmp(pch, "", 1))
	    pch = strtok(NULL, CLI_SPACE);
    }
}

/**
 * find_cli_callback_descr - find a callback in a list of modules
 * @module_name:	Name of the module to find
 * @modules_list:	Lits of modules among which to find @module_name
 * @module_found:	Pointer to the matched module, NULL if not found
 *
 * Given a module name and a list of possible modules, find the corresponding
 * module structure that matches the module name and store it in @module_found.
 **/
void find_cli_callback_descr(const char *module_name,
			     struct cli_module_descr *modules_list,
			     struct cli_callback_descr **module_found)
{
    int modules_iter = 0;

    if (modules_list == NULL)
	goto not_found;

    /* Find the callback to execute */
    while (modules_list->modules[modules_iter].name &&
	   strcmp(module_name, modules_list->modules[modules_iter].name) != 0)
	modules_iter++;

    if (modules_list->modules[modules_iter].name) {
	*module_found = &(modules_list->modules[modules_iter]);
	dprintf("CLI DEBUG: module %s found\n", (*module_found)->name);
	return;
    }

not_found:
    *module_found = NULL;
    return;
}

/**
 * autocomplete_command - print matching commands
 * @command:	Beginning of the command
 *
 * Given a string @command, print all availables commands starting with
 * @command. Commands are found within the list of commands for the current
 * mode and the hdt mode (if the current mode is not hdt).
 **/
static void autocomplete_command(char *command)
{
    int j = 0;
    struct cli_callback_descr *associated_module = NULL;

    /* First take care of the two special commands: 'show' and 'set' */
    if (strncmp(CLI_SHOW, command, strlen(command)) == 0) {
	printf("%s\n", CLI_SHOW);
	autocomplete_add_token_to_list(CLI_SHOW);
    }
    if (strncmp(CLI_SET, command, strlen(command)) == 0) {
	printf("%s\n", CLI_SET);
	autocomplete_add_token_to_list(CLI_SET);
    }

    /*
     * Then, go through the modes for the special case
     *      '<mode>' -> 'set mode <mode>'
     */
    while (list_modes[j]) {
	if (strncmp(list_modes[j]->name, command, strlen(command)) == 0) {
	    printf("%s\n", list_modes[j]->name);
	    autocomplete_add_token_to_list(list_modes[j]->name);
	}
	j++;
    }

    /*
     * Let's go now through the list of default_modules for the current mode
     * (single token commands for the current_mode)
     */
    j = 0;
    if (current_mode->default_modules && current_mode->default_modules->modules) {
	while (current_mode->default_modules->modules[j].name) {
	    if (strncmp(current_mode->default_modules->modules[j].name,
			command, strlen(command)) == 0) {
		printf("%s\n", current_mode->default_modules->modules[j].name);
		autocomplete_add_token_to_list(current_mode->default_modules->
					       modules[j].name);
	    }
	    j++;
	}
    }

    /*
     * Finally, if the current_mode is not hdt, list the available
     * default_modules of hdt (these are always available from any mode).
     */
    if (current_mode->mode == HDT_MODE)
	return;

    if (!hdt_mode.default_modules || !hdt_mode.default_modules->modules)
	return;

    j = 0;
    while (hdt_mode.default_modules &&
	   hdt_mode.default_modules->modules[j].name) {
	/*
	 * Any default command that is present in hdt mode but
	 * not in the current mode is available. A default
	 * command can be redefined in the current mode though.
	 * This next call tests this use case: if it is
	 * overwritten, do not print it again.
	 */
	find_cli_callback_descr(hdt_mode.default_modules->modules[j].name,
				current_mode->default_modules,
				&associated_module);
	if (associated_module == NULL &&
	    strncmp(command,
		    hdt_mode.default_modules->modules[j].name,
		    strlen(command)) == 0) {
	    printf("%s\n", hdt_mode.default_modules->modules[j].name);
	    autocomplete_add_token_to_list(hdt_mode.default_modules->modules[j].
					   name);
	}
	j++;
    }
}

/**
 * autocomplete_module - print matching modules
 * @command:	Command on the command line (not NULL)
 * @module:	Beginning of the module
 *
 * Given a command @command and a string @module, print all availables modules
 * starting with @module for command @command. Commands are found within the
 * list of commands for the current mode and the hdt mode (if the current mode
 * is not hdt).
 **/
static void autocomplete_module(char *command, char *module)
{
    int j = 0;
    char autocomplete_full_line[MAX_LINE_SIZE];

    if (strncmp(CLI_SHOW, command, strlen(command)) == 0) {
	if (!current_mode->show_modules || !current_mode->show_modules->modules)
	    return;

	while (current_mode->show_modules->modules[j].name) {
	    if (strncmp(current_mode->show_modules->modules[j].name,
			module, strlen(module)) == 0) {
		printf("%s\n", current_mode->show_modules->modules[j].name);
		sprintf(autocomplete_full_line, "%s %s",
			CLI_SHOW, current_mode->show_modules->modules[j].name);
		autocomplete_add_token_to_list(autocomplete_full_line);
	    }
	    j++;
	}
    } else if (strncmp(CLI_SET, command, strlen(command)) == 0) {
	j = 0;
	if (!current_mode->set_modules || !current_mode->set_modules->modules)
	    return;

	while (current_mode->set_modules->modules[j].name) {
	    if (strncmp(current_mode->set_modules->modules[j].name,
			module, strlen(module)) == 0) {
		printf("%s\n", current_mode->set_modules->modules[j].name);
		sprintf(autocomplete_full_line, "%s %s",
			CLI_SET, current_mode->set_modules->modules[j].name);
		autocomplete_add_token_to_list(autocomplete_full_line);
	    }
	    j++;
	}
    }
}

/**
 * autocomplete - find possible matches for a command line
 * @line:	command line to parse
 **/
static void autocomplete(char *line)
{
    int i;
    int argc = 0;
    char *command = NULL, *module = NULL;
    char **argv = NULL;

    parse_command_line(line, &command, &module, &argc, argv);

    dprintf("CLI DEBUG autocomplete: before checking args\n");
    /* If the user specified arguments, there is nothing we can complete */
    if (argc != 0)
	goto out;

    /* No argument, (the start of) a module has been specified */
    if (module != NULL) {
	autocomplete_module(command, module);
	free(module);
	goto out;
    }

    /* No argument, no module, (the start of) a command has been specified */
    if (command != NULL) {
	autocomplete_command(command);
	free(command);
	goto out;
    }

out:
    /* Let's not forget to clean ourselves */
    for (i = 0; i < argc; i++)
	free(argv[i]);
    if (argc > 0)
	free(argv);
    return;
}

/**
 * exec_command - main logic to map the command line to callbacks
 **/
static void exec_command(char *line, struct s_hardware *hardware)
{
    int argc, i = 0;
    char *command = NULL, *module = NULL;
    char **argv = NULL;
    struct cli_callback_descr *current_module = NULL;

    /* This will allocate memory for command and module */
    parse_command_line(line, &command, &module, &argc, argv);

    dprintf("CLI DEBUG exec: Checking for aliases\n");
    /*
     * Expand shortcuts, if needed
     * This will allocate memory for argc/argv
     */
    expand_aliases(line, &command, &module, &argc, argv);
    
    find_cli_callback_descr(command, current_mode->default_modules,
				&current_module);

    if ((module == NULL) || (current_module->nomodule == true)) {
	dprintf("CLI DEBUG exec : single command detected\n");
	/*
	 * A single word was specified: look at the list of default
	 * commands in the current mode to see if there is a match.
	 * If not, it may be a generic function (exit, help, ...). These
	 * are stored in the list of default commands of the hdt mode.
	 */

	/* First of all it the command doesn't need module, let's rework the arguments */
	if ((current_module->nomodule == true) && ( module != NULL)) {
		dprintf("CLI_DEBUG exec: Reworking arguments with argc=%d\n",argc);
		char **new_argv=NULL;
    		new_argv=malloc((argc + 2)*sizeof(char *));
		for (int argc_iter=0; argc_iter<argc; argc_iter++) {
			dprintf("CLI_DEBUG exec rework : copy %d to %d (%s)\n",argc_iter,argc_iter+1,argv[argc_iter]);
			new_argv[argc_iter+1] = malloc(strlen(argv[argc_iter]));
			strlcpy(new_argv[argc_iter+1], argv[argc_iter], strlen(argv[argc_iter]));
			free(argv[argc_iter]);
		}
		new_argv[0] = malloc(strlen(module)*sizeof(char));
		strlcpy(new_argv[0], module, strlen(module));
		argc++;
		free(argv);
		argv=new_argv;
	}

	if (current_module != NULL)
	    current_module->exec(argc, argv, hardware);
	else if (!strncmp(command, CLI_SHOW, sizeof(CLI_SHOW) - 1) &&
		 current_mode->show_modules != NULL &&
		 current_mode->show_modules->default_callback != NULL)
	    current_mode->show_modules->default_callback(argc, argv, hardware);
	else if (!strncmp(command, CLI_SET, sizeof(CLI_SET) - 1) &&
		 current_mode->set_modules != NULL &&
		 current_mode->set_modules->default_callback != NULL)
	    current_mode->set_modules->default_callback(argc, argv, hardware);
	else {
	    find_cli_callback_descr(command, hdt_mode.default_modules,
				    &current_module);
	    if (current_module != NULL)
		current_module->exec(argc, argv, hardware);
	    else
		more_printf("unknown command: '%s'\n", command);
	}
    } else {
	/*
	 * A module has been specified! We now need to find the type of command.
	 *
	 * The syntax of the cli is the following:
	 *    <type of command> <module on which to operate> <args>
	 * e.g.
	 *    dmi> show system
	 *    dmi> show bank 1
	 *    dmi> show memory 0 1
	 *    pci> show device 12
	 *    hdt> set mode dmi
	 */
	if (!strncmp(command, CLI_SHOW, sizeof(CLI_SHOW) - 1)) {
	    dprintf("CLI DEBUG exec: %s command detected\n", CLI_SHOW);
	    /* Look first for a 'show' callback in the current mode */
	    find_cli_callback_descr(module, current_mode->show_modules,
				    &current_module);
	    /* Execute the callback, if found */
	    if (current_module != NULL)
		current_module->exec(argc, argv, hardware);
	    else {
		dprintf("CLI DEBUG exec: Looking for callback\n");
		/* Look now for a 'show' callback in the hdt mode */
		find_cli_callback_descr(module, hdt_mode.show_modules,
					&current_module);
		/* Execute the callback, if found */
		if (current_module != NULL)
		    current_module->exec(argc, argv, hardware);
		else
		    printf("unknown module: '%s'\n", module);
	    }
	} else if (!strncmp(command, CLI_SET, sizeof(CLI_SET) - 1)) {
	    dprintf("CLI DEBUG exec : %s command detected\n", CLI_SET);
	    /* Look now for a 'set' callback in the hdt mode */
	    find_cli_callback_descr(module, current_mode->set_modules,
				    &current_module);
	    /* Execute the callback, if found */
	    if (current_module != NULL)
		current_module->exec(argc, argv, hardware);
	    else {
		/* Look now for a 'set' callback in the hdt mode */
		find_cli_callback_descr(module, hdt_mode.set_modules,
					&current_module);
		/* Execute the callback, if found */
		if (current_module != NULL)
		    current_module->exec(argc, argv, hardware);
		else
		    printf("unknown module: '%s'\n", module);
	    }
	}
    }

    /* Let's not forget to clean ourselves */
    if (command != NULL)
	free(command);
    if (module != NULL)
	free(module);
    for (i = 0; i < argc; i++)
	free(argv[i]);
    if (argc > 0)
	free(argv);
}

static void reset_prompt(void)
{
    /* No need to display the prompt if we exit */
    if (hdt_cli.mode != EXIT_MODE) {
	printf("%s", hdt_cli.prompt);
	/* Reset the line */
	hdt_cli.cursor_pos = 0;
    }
}

void start_auto_mode(struct s_hardware *hardware)
{
    char *mypch;
    int nb_commands = 0;
    char *commands[MAX_NB_AUTO_COMMANDS];

    more_printf("\nEntering Auto mode\n");

    /* Protecting the auto_label from the strtok modifications */
    char *temp = strdup(hardware->auto_label);

    /* Searching & saving all commands */
    mypch = strtok(temp, AUTO_SEPARATOR);
    while (mypch != NULL) {
	if ((strlen(remove_spaces(mypch)) > 0) &&
	    (remove_spaces(mypch)[0] != AUTO_SEPARATOR[0])) {
	    nb_commands++;
	    if ((commands[nb_commands] = malloc(AUTO_COMMAND_SIZE)) != NULL) {
		sprintf(commands[nb_commands], "%s", remove_spaces(mypch));
	    } else
		nb_commands--;
	}
	mypch = strtok(NULL, AUTO_SEPARATOR);
    }

    /* Executing found commands */
    for (int i = 1; i <= nb_commands; i++) {
	if (commands[i]) {
	    if (!quiet)
		more_printf("%s%s\n", hdt_cli.prompt, commands[i]);
	    exec_command(commands[i], hardware);
	    free(commands[i]);
	}
    }

    if (!quiet)
	more_printf("\nExiting Auto mode\n");

    more_printf("\n");
}

void print_history(int argc, char **argv, struct s_hardware * hardware)
{
    (void)argc;
    (void)argv;
    (void)hardware;

    reset_more_printf();
    for (int i = 1; i <= MAX_HISTORY_SIZE; i++) {
	if (i == hdt_cli.history_pos) {
	    more_printf("*%d:'%s'\n", i, hdt_cli.history[i]);
	    continue;
	}
	if (strlen(hdt_cli.history[i]) == 0)
	    continue;
	more_printf(" %d:'%s'\n", i, hdt_cli.history[i]);
    }
}

/* Code that manages the cli mode */
void start_cli_mode(struct s_hardware *hardware)
{
    int current_key = 0;
    int future_history_pos = 1;	/* position of the next position in the history */
    int current_future_history_pos = 1;	/* Temp variable */
    bool display_history = true;	/* Temp Variable */
    char temp_command[MAX_LINE_SIZE];

    hdt_cli.cursor_pos = 0;
    memset(hdt_cli.history, 0, sizeof(hdt_cli.history));
    hdt_cli.history_pos = 1;
    hdt_cli.max_history_pos = 1;

    /* Find the mode selected */
    set_mode(HDT_MODE, hardware);
    find_cli_mode_descr(hdt_cli.mode, &current_mode);
    if (current_mode == NULL) {
	/* Shouldn't get here... */
	more_printf("!!! BUG: Mode '%d' unknown.\n", hdt_cli.mode);
	return;
    }

    /* Start the auto mode if the command line is set */
    if (strlen(hardware->auto_label) > 0) {
	start_auto_mode(hardware);
    }

    more_printf("Entering CLI mode\n");

    reset_prompt();

    while (hdt_cli.mode != EXIT_MODE) {

	/* Display the cursor */
	display_cursor(true);

	/* Let's put the cursor blinking until we get an input */
	set_cursor_blink(true);

	/* We wait endlessly for a keyboard input */
	current_key = get_key(stdin, 0);

	/* We have to cancel the blinking mode to prevent
	 * input text to blink */
	set_cursor_blink(false);

	/* Reset autocomplete buffer unless TAB is pressed */
	if (current_key != KEY_TAB)
	    autocomplete_destroy_list();

	switch (current_key) {
	    /* clear until then end of line */
	case KEY_CTRL('k'):
	    /* Clear the end of the line */
	    clear_end_of_line();
	    memset(&INPUT[hdt_cli.cursor_pos], 0,
		   strlen(INPUT) - hdt_cli.cursor_pos);
	    break;

	case KEY_CTRL('c'):
	    printf("\n");
	    reset_prompt();
	    break;

	case KEY_LEFT:
	    if (hdt_cli.cursor_pos > 0) {
		move_cursor_left(1);
		hdt_cli.cursor_pos--;
	    }
	    break;

	case KEY_RIGHT:
	    if (hdt_cli.cursor_pos < (int)strlen(INPUT)) {
		move_cursor_right(1);
		hdt_cli.cursor_pos++;
	    }
	    break;

	case KEY_CTRL('e'):
	case KEY_END:
	    /* Calling with a 0 value will make the cursor move */
	    /* So, let's move the cursor only if needed */
	    if ((strlen(INPUT) - hdt_cli.cursor_pos) > 0) {
		/* Return to the begining of line */
		move_cursor_right(strlen(INPUT) - hdt_cli.cursor_pos);
		hdt_cli.cursor_pos = strlen(INPUT);
	    }
	    break;

	case KEY_CTRL('a'):
	case KEY_HOME:
	    /* Calling with a 0 value will make the cursor move */
	    /* So, let's move the cursor only if needed */
	    if (hdt_cli.cursor_pos > 0) {
		/* Return to the begining of line */
		move_cursor_left(hdt_cli.cursor_pos);
		hdt_cli.cursor_pos = 0;
	    }
	    break;

	case KEY_UP:

	    /* Saving future position */
	    current_future_history_pos = future_history_pos;

	    /* We have to compute the next position */
	    if (future_history_pos == 1) {
		future_history_pos = MAX_HISTORY_SIZE;
	    } else {
		future_history_pos--;
	    }

	    /* Does the next position is valid */
	    if (strlen(hdt_cli.history[future_history_pos]) == 0) {
		/* Position is invalid, restoring position */
		future_history_pos = current_future_history_pos;
		break;
	    }

	    /* Let's make that future position the one we use */
	    memset(INPUT, 0, sizeof(INPUT));
	    strlcpy(INPUT, hdt_cli.history[future_history_pos], sizeof(INPUT));

	    /* Clear the line */
	    clear_line();

	    /* Move to the begining of line */
	    move_cursor_to_column(0);

	    reset_prompt();
	    printf("%s", INPUT);
	    hdt_cli.cursor_pos = strlen(INPUT);
	    break;

	case KEY_DOWN:
	    display_history = true;

	    /* Saving future position */
	    current_future_history_pos = future_history_pos;

	    if (future_history_pos == MAX_HISTORY_SIZE) {
		future_history_pos = 1;
	    } else {
		future_history_pos++;
	    }

	    /* Does the next position is valid */
	    if (strlen(hdt_cli.history[future_history_pos]) == 0)
		display_history = false;

	    /* An exception is made to reach the last empty line */
	    if (future_history_pos == hdt_cli.max_history_pos)
		display_history = true;

	    if (display_history == false) {
		/* Position is invalid, restoring position */
		future_history_pos = current_future_history_pos;
		break;
	    }

	    /* Let's make that future position the one we use */
	    memset(INPUT, 0, sizeof(INPUT));
	    strlcpy(INPUT, hdt_cli.history[future_history_pos], sizeof(INPUT));

	    /* Clear the line */
	    clear_line();

	    /* Move to the begining of line */
	    move_cursor_to_column(0);

	    reset_prompt();
	    printf("%s", INPUT);
	    hdt_cli.cursor_pos = strlen(INPUT);
	    break;

	case KEY_TAB:
	    if (autocomplete_backlog) {
		clear_line();
		/* Move to the begining of line */
		move_cursor_to_column(0);
		reset_prompt();
		printf("%s", autocomplete_last_seen->autocomplete_token);
		strlcpy(INPUT,
			autocomplete_last_seen->autocomplete_token,
			sizeof(INPUT));
		hdt_cli.cursor_pos = strlen(INPUT);

		/* Cycle through the list */
		autocomplete_last_seen = autocomplete_last_seen->next;
		if (autocomplete_last_seen == NULL)
		    autocomplete_last_seen = autocomplete_head;
	    } else {
		printf("\n");
		autocomplete(skip_spaces(INPUT));
		autocomplete_last_seen = autocomplete_head;

		printf("%s%s", hdt_cli.prompt, INPUT);
	    }
	    break;

	case KEY_ENTER:
	    printf("\n");
	    if (strlen(remove_spaces(INPUT)) < 1) {
		reset_prompt();
		break;
	    }
	    exec_command(remove_spaces(INPUT), hardware);
	    hdt_cli.history_pos++;

	    /* Did we reach the end of the history ?*/
	    if (hdt_cli.history_pos > MAX_HISTORY_SIZE) {
		/* Let's return at the beginning */    
		hdt_cli.history_pos = 1;
	    }

	    /* Does the next position is already used ?
	     * If yes, we are cycling in history */
	    if (strlen(INPUT) > 0) {
		/* Let's clean that entry */
		memset(&INPUT,0,sizeof(INPUT));
	    }

	    future_history_pos = hdt_cli.history_pos;
	    if (hdt_cli.history_pos > hdt_cli.max_history_pos)
		hdt_cli.max_history_pos = hdt_cli.history_pos;
	    reset_prompt();
	    break;

	case KEY_CTRL('d'):
	case KEY_DELETE:
	    /* No need to delete when input is empty */
	    if (strlen(INPUT) == 0)
		break;
	    /* Don't delete when cursor is at the end of the line */
	    if (hdt_cli.cursor_pos >= strlen(INPUT))
		break;

	    for (int c = hdt_cli.cursor_pos; c < (int)strlen(INPUT) - 1; c++)
		INPUT[c] = INPUT[c + 1];
	    INPUT[strlen(INPUT) - 1] = '\0';

	    /* Clear the end of the line */
	    clear_end_of_line();

	    /* Print the resulting buffer */
	    printf("%s", INPUT + hdt_cli.cursor_pos);

	    /* Replace the cursor at the proper place */
	    if (strlen(INPUT + hdt_cli.cursor_pos) > 0)
		move_cursor_left(strlen(INPUT + hdt_cli.cursor_pos));
	    break;

	case KEY_DEL:
	case KEY_BACKSPACE:
	    /* Don't delete prompt */
	    if (hdt_cli.cursor_pos == 0)
		break;

	    for (int c = hdt_cli.cursor_pos - 1;
		 c < (int)strlen(INPUT) - 1; c++)
		INPUT[c] = INPUT[c + 1];
	    INPUT[strlen(INPUT) - 1] = '\0';

	    /* Get one char back */
	    move_cursor_left(1);

	    /* Clear the end of the line */
	    clear_end_of_line();

	    /* Print the resulting buffer */
	    printf("%s", INPUT + hdt_cli.cursor_pos - 1);

	    /* Realing to a char before the place we were */
	    hdt_cli.cursor_pos--;
	    move_cursor_to_column(strlen(hdt_cli.prompt) + hdt_cli.cursor_pos +
				  1);

	    break;

	case KEY_F1:
	    printf("\n");
	    exec_command(CLI_HELP, hardware);
	    reset_prompt();
	    break;

	default:
	    if ((current_key < 0x20) || (current_key > 0x7e))
		break;
	    /* Prevent overflow */
	    if (hdt_cli.cursor_pos > MAX_LINE_SIZE - 2)
		break;
	    /* If we aren't at the end of the input line, let's insert */
	    if (hdt_cli.cursor_pos < (int)strlen(INPUT)) {
		char key[2];
		int trailing_chars = strlen(INPUT) - hdt_cli.cursor_pos;
		memset(temp_command, 0, sizeof(temp_command));
		strlcpy(temp_command, INPUT, hdt_cli.cursor_pos);
		sprintf(key, "%c", current_key);
		strncat(temp_command, key, 1);
		strncat(temp_command,
			INPUT + hdt_cli.cursor_pos, trailing_chars);
		memset(INPUT, 0, sizeof(INPUT));
		snprintf(INPUT, sizeof(INPUT), "%s", temp_command);

		/* Clear the end of the line */
		clear_end_of_line();

		/* Print the resulting buffer */
		printf("%s", INPUT + hdt_cli.cursor_pos);

		/* Return where we must put the new char */
		move_cursor_left(trailing_chars);

	    } else {
		putchar(current_key);
		INPUT[hdt_cli.cursor_pos] = current_key;
	    }
	    hdt_cli.cursor_pos++;
	    break;
	}
    }
}
