/*
   * Copyright 2010-2011 Calxeda, Inc.
   *

   * SPDX-License-Identifier:	GPL-2.0+

   */
  
  #include <common.h>
  #include <malloc.h>
  #include <errno.h>
  #include <linux/list.h>
  
  #include "menu.h"
  
  /*
   * Internally, each item in a menu is represented by a struct menu_item.
   *
   * These items will be alloc'd and initialized by menu_item_add and destroyed
   * by menu_item_destroy, and the consumer of the interface never sees that
   * this struct is used at all.
   */
  struct menu_item {
  	char *key;
  	void *data;
  	struct list_head list;
  };
  
  /*
   * The menu is composed of a list of items along with settings and callbacks
   * provided by the user. An incomplete definition of this struct is available
   * in menu.h, but the full definition is here to prevent consumers from
   * relying on its contents.
   */
  struct menu {
  	struct menu_item *default_item;

  	int timeout;

  	char *title;
  	int prompt;
  	void (*item_data_print)(void *);

  	char *(*item_choice)(void *);
  	void *item_choice_data;

  	struct list_head items;
  };
  
  /*
   * An iterator function for menu items. callback will be called for each item
   * in m, with m, a pointer to the item, and extra being passed to callback. If
   * callback returns a value other than NULL, iteration stops and the value
   * return by callback is returned from menu_items_iter.  This allows it to be
   * used for search type operations. It is also safe for callback to remove the
   * item from the list of items.
   */
  static inline void *menu_items_iter(struct menu *m,
  		void *(*callback)(struct menu *, struct menu_item *, void *),
  		void *extra)
  {
  	struct list_head *pos, *n;
  	struct menu_item *item;
  	void *ret;
  
  	list_for_each_safe(pos, n, &m->items) {
  		item = list_entry(pos, struct menu_item, list);
  
  		ret = callback(m, item, extra);
  
  		if (ret)
  			return ret;
  	}
  
  	return NULL;
  }
  
  /*
   * Print a menu_item. If the consumer provided an item_data_print function
   * when creating the menu, call it with a pointer to the item's private data.
   * Otherwise, print the key of the item.
   */
  static inline void *menu_item_print(struct menu *m,
  				struct menu_item *item,
  				void *extra)
  {

  	if (!m->item_data_print) {

  		puts(item->key);

  		putc('
  ');
  	} else {

  		m->item_data_print(item->data);

  	}

  
  	return NULL;
  }
  
  /*
   * Free the memory used by a menu item. This includes the memory used by its
   * key.
   */
  static inline void *menu_item_destroy(struct menu *m,
  				struct menu_item *item,
  				void *extra)
  {
  	if (item->key)
  		free(item->key);
  
  	free(item);
  
  	return NULL;
  }

  void __menu_display_statusline(struct menu *m)
  {
  	return;
  }
  void menu_display_statusline(struct menu *m)
  	__attribute__ ((weak, alias("__menu_display_statusline")));

  /*
   * Display a menu so the user can make a choice of an item. First display its
   * title, if any, and then each item in the menu.
   */
  static inline void menu_display(struct menu *m)
  {

  	if (m->title) {
  		puts(m->title);
  		putc('
  ');
  	}

  	menu_display_statusline(m);

  
  	menu_items_iter(m, menu_item_print, NULL);
  }
  
  /*
   * Check if an item's key matches a provided string, pointed to by extra. If
   * extra is NULL, an item with a NULL key will match. Otherwise, the item's
   * key has to match according to strcmp.
   *
   * This is called via menu_items_iter, so it returns a pointer to the item if
   * the key matches, and returns NULL otherwise.
   */
  static inline void *menu_item_key_match(struct menu *m,
  			struct menu_item *item, void *extra)
  {
  	char *item_key = extra;
  
  	if (!item_key || !item->key) {
  		if (item_key == item->key)
  			return item;
  
  		return NULL;
  	}
  
  	if (strcmp(item->key, item_key) == 0)
  		return item;
  
  	return NULL;
  }
  
  /*
   * Find the first item with a key matching item_key, if any exists.
   */
  static inline struct menu_item *menu_item_by_key(struct menu *m,
  							char *item_key)
  {
  	return menu_items_iter(m, menu_item_key_match, item_key);
  }
  
  /*

   * Set *choice to point to the default item's data, if any default item was
   * set, and returns 1. If no default item was set, returns -ENOENT.
   */

  int menu_default_choice(struct menu *m, void **choice)

  {
  	if (m->default_item) {
  		*choice = m->default_item->data;
  		return 1;
  	}
  
  	return -ENOENT;
  }
  
  /*
   * Displays the menu and asks the user to choose an item. *choice will point
   * to the private data of the item the user chooses. The user makes a choice
   * by inputting a string matching the key of an item. Invalid choices will
   * cause the user to be prompted again, repeatedly, until the user makes a
   * valid choice. The user can exit the menu without making a choice via ^c.
   *
   * Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
   */
  static inline int menu_interactive_choice(struct menu *m, void **choice)
  {
  	char cbuf[CONFIG_SYS_CBSIZE];
  	struct menu_item *choice_item = NULL;
  	int readret;
  
  	while (!choice_item) {
  		cbuf[0] = '\0';
  
  		menu_display(m);

  		if (!m->item_choice) {
  			readret = readline_into_buffer("Enter choice: ", cbuf,
  					m->timeout / 10);

  			if (readret >= 0) {
  				choice_item = menu_item_by_key(m, cbuf);
  				if (!choice_item)
  					printf("%s not found
  ", cbuf);
  			} else {
  				return menu_default_choice(m, choice);

  			}

  		} else {
  			char *key = m->item_choice(m->item_choice_data);
  
  			if (key)
  				choice_item = menu_item_by_key(m, key);
  		}
  
  		if (!choice_item)
  			m->timeout = 0;

  	}
  
  	*choice = choice_item->data;
  
  	return 1;
  }
  
  /*
   * menu_default_set() - Sets the default choice for the menu. This is safe to
   * call more than once on a menu.
   *
   * m - Points to a menu created by menu_create().
   *
   * item_key - Points to a string that, when compared using strcmp, matches the
   * key for an existing item in the menu.
   *
   * Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
   * key matching item_key is found.
   */
  int menu_default_set(struct menu *m, char *item_key)
  {
  	struct menu_item *item;
  
  	if (!m)
  		return -EINVAL;
  
  	item = menu_item_by_key(m, item_key);
  
  	if (!item)
  		return -ENOENT;
  
  	m->default_item = item;
  
  	return 1;
  }
  
  /*
   * menu_get_choice() - Returns the user's selected menu entry, or the default

   * if the menu is set to not prompt or the timeout expires. This is safe to
   * call more than once.

   *
   * m - Points to a menu created by menu_create().
   *
   * choice - Points to a location that will store a pointer to the selected
   * menu item. If no item is selected or there is an error, no value will be
   * written at the location it points to.
   *
   * Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no

   * default has been set and the menu is set to not prompt or the timeout
   * expires, or -EINTR if the user exits the menu via ^c.

   */
  int menu_get_choice(struct menu *m, void **choice)
  {
  	if (!m || !choice)
  		return -EINVAL;

  	if (!m->prompt)

  		return menu_default_choice(m, choice);
  
  	return menu_interactive_choice(m, choice);
  }
  
  /*
   * menu_item_add() - Adds or replaces a menu item. Note that this replaces the
   * data of an item if it already exists, but doesn't change the order of the
   * item.
   *
   * m - Points to a menu created by menu_create().
   *
   * item_key - Points to a string that will uniquely identify the item.  The
   * string will be copied to internal storage, and is safe to discard after
   * passing to menu_item_add.
   *
   * item_data - An opaque pointer associated with an item. It is never
   * dereferenced internally, but will be passed to the item_data_print, and
   * will be returned from menu_get_choice if the menu item is selected.
   *
   * Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
   * insufficient memory to add the menu item.
   */
  int menu_item_add(struct menu *m, char *item_key, void *item_data)
  {
  	struct menu_item *item;
  
  	if (!m)
  		return -EINVAL;
  
  	item = menu_item_by_key(m, item_key);
  
  	if (item) {
  		item->data = item_data;
  		return 1;
  	}
  
  	item = malloc(sizeof *item);
  	if (!item)
  		return -ENOMEM;
  
  	item->key = strdup(item_key);
  
  	if (!item->key) {
  		free(item);
  		return -ENOMEM;
  	}
  
  	item->data = item_data;
  
  	list_add_tail(&item->list, &m->items);
  
  	return 1;
  }
  
  /*
   * menu_create() - Creates a menu handle with default settings
   *
   * title - If not NULL, points to a string that will be displayed before the
   * list of menu items. It will be copied to internal storage, and is safe to
   * discard after passing to menu_create().
   *

   * timeout - A delay in seconds to wait for user input. If 0, timeout is
   * disabled, and the default choice will be returned unless prompt is 1.
   *
   * prompt - If 0, don't ask for user input unless there is an interrupted
   * timeout. If 1, the user will be prompted for input regardless of the value
   * of timeout.

   *
   * item_data_print - If not NULL, will be called for each item when the menu
   * is displayed, with the pointer to the item's data passed as the argument.
   * If NULL, each item's key will be printed instead.  Since an item's key is
   * what must be entered to select an item, the item_data_print function should
   * make it obvious what the key for each entry is.
   *

   * item_choice - If not NULL, will be called when asking the user to choose an
   * item. Returns a key string corresponding to the choosen item or NULL if
   * no item has been selected.
   *
   * item_choice_data - Will be passed as the argument to the item_choice function
   *

   * Returns a pointer to the menu if successful, or NULL if there is
   * insufficient memory available to create the menu.
   */

  struct menu *menu_create(char *title, int timeout, int prompt,

  				void (*item_data_print)(void *),
  				char *(*item_choice)(void *),
  				void *item_choice_data)

  {
  	struct menu *m;
  
  	m = malloc(sizeof *m);
  
  	if (!m)
  		return NULL;
  
  	m->default_item = NULL;
  	m->prompt = prompt;

  	m->timeout = timeout;

  	m->item_data_print = item_data_print;

  	m->item_choice = item_choice;
  	m->item_choice_data = item_choice_data;

  
  	if (title) {
  		m->title = strdup(title);
  		if (!m->title) {
  			free(m);
  			return NULL;
  		}
  	} else
  		m->title = NULL;
  
  
  	INIT_LIST_HEAD(&m->items);
  
  	return m;
  }
  
  /*
   * menu_destroy() - frees the memory used by a menu and its items.
   *
   * m - Points to a menu created by menu_create().
   *
   * Returns 1 if successful, or -EINVAL if m is NULL.
   */
  int menu_destroy(struct menu *m)
  {
  	if (!m)
  		return -EINVAL;
  
  	menu_items_iter(m, menu_item_destroy, NULL);
  
  	if (m->title)
  		free(m->title);
  
  	free(m);
  
  	return 1;
  }