/* Adapted from GLIB - Library of useful routines for C programming
 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

/*
 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
 * file for a list of people on the GLib Team.  See the ChangeLog
 * files for a list of changes.  These files are distributed with
 * GLib at ftp://ftp.gtk.org/pub/gtk/.
 */

/*
 * Modified by Jose Antonio Ortega Ruiz 2014, for inclusion in MDK due
 * to deprecation in new versions of Glib.  Only changes are renaming
 * GCompletion to Completion and g_completion to completion.
 */

/*
 * MT safe
 */

#include "config.h"

#include "completion.h"

#include <glib.h>
#include <string.h>

/**
 * SECTION:completion
 * @title: Automatic String Completion
 * @short_description: support for automatic completion using a group
 *                     of target strings
 *
 * #Completion provides support for automatic completion of a string
 * using any group of target strings. It is typically used for file
 * name completion as is common in many UNIX shells.
 *
 * A #Completion is created using completion_new(). Target items are
 * added and removed with completion_add_items(),
 * completion_remove_items() and completion_clear_items(). A
 * completion attempt is requested with completion_complete() or
 * completion_complete_utf8(). When no longer needed, the
 * #Completion is freed with completion_free().
 *
 * Items in the completion can be simple strings (e.g. filenames), or
 * pointers to arbitrary data structures. If data structures are used
 * you must provide a #CompletionFunc in completion_new(), which
 * retrieves the item's string from the data structure. You can change
 * the way in which strings are compared by setting a different
 * #CompletionStrncmpFunc in completion_set_compare().
 *
 * Completion has been marked as deprecated, since this API is rarely
 * used and not very actively maintained.
 **/

/**
 * Completion:
 * @items: list of target items (strings or data structures).
 * @func: function which is called to get the string associated with a
 *        target item. It is %NULL if the target items are strings.
 * @prefix: the last prefix passed to completion_complete() or
 *          completion_complete_utf8().
 * @cache: the list of items which begin with @prefix.
 * @strncmp_func: The function to use when comparing strings.  Use
 *                completion_set_compare() to modify this function.
 *
 * The data structure used for automatic completion.
 **/

/**
 * CompletionFunc:
 * @Param1: the completion item.
 *
 * Specifies the type of the function passed to completion_new(). It
 * should return the string corresponding to the given target item.
 * This is used when you use data structures as #Completion items.
 *
 * Returns: the string corresponding to the item.
 **/

/**
 * CompletionStrncmpFunc:
 * @s1: string to compare with @s2.
 * @s2: string to compare with @s1.
 * @n: maximal number of bytes to compare.
 *
 * Specifies the type of the function passed to
 * completion_set_compare(). This is used when you use strings as
 * #Completion items.
 *
 * Returns: an integer less than, equal to, or greater than zero if
 *          the first @n bytes of @s1 is found, respectively, to be
 *          less than, to match, or to be greater than the first @n
 *          bytes of @s2.
 **/

static void completion_check_cache (Completion* cmp,
				    gchar**	 new_prefix);

/**
 * completion_new:
 * @func: the function to be called to return the string representing
 *        an item in the #Completion, or %NULL if strings are going to
 *        be used as the #Completion items.
 *
 * Creates a new #Completion.
 *
 * Returns: the new #Completion.
 **/
Completion*
completion_new (CompletionFunc func)
{
  Completion* gcomp;

  gcomp = g_new (Completion, 1);
  gcomp->items = NULL;
  gcomp->cache = NULL;
  gcomp->prefix = NULL;
  gcomp->func = func;
  gcomp->strncmp_func = strncmp;

  return gcomp;
}

/**
 * completion_add_items:
 * @cmp: the #Completion.
 * @items: (transfer none): the list of items to add.
 *
 * Adds items to the #Completion.
 *
 * Deprecated: 2.26: Rarely used API
 **/
void
completion_add_items (Completion* cmp,
                      GList*	     items)
{
  GList* it;

  g_return_if_fail (cmp != NULL);

  /* optimize adding to cache? */
  if (cmp->cache)
    {
      g_list_free (cmp->cache);
      cmp->cache = NULL;
    }

  if (cmp->prefix)
    {
      g_free (cmp->prefix);
      cmp->prefix = NULL;
    }

  it = items;
  while (it)
    {
      cmp->items = g_list_prepend (cmp->items, it->data);
      it = it->next;
    }
}

/**
 * completion_remove_items:
 * @cmp: the #Completion.
 * @items: (transfer none): the items to remove.
 *
 * Removes items from a #Completion. The items are not freed, so if the memory
 * was dynamically allocated, free @items with g_list_free_full() after calling
 * this function.
 *
 * Deprecated: 2.26: Rarely used API
 **/
void
completion_remove_items (Completion* cmp,
                         GList*	items)
{
  GList* it;

  g_return_if_fail (cmp != NULL);

  it = items;
  while (cmp->items && it)
    {
      cmp->items = g_list_remove (cmp->items, it->data);
      it = it->next;
    }

  it = items;
  while (cmp->cache && it)
    {
      cmp->cache = g_list_remove(cmp->cache, it->data);
      it = it->next;
    }
}

/**
 * completion_clear_items:
 * @cmp: the #Completion.
 *
 * Removes all items from the #Completion. The items are not freed, so if the
 * memory was dynamically allocated, it should be freed after calling this
 * function.
 *
 * Deprecated: 2.26: Rarely used API
 **/
void
completion_clear_items (Completion* cmp)
{
  g_return_if_fail (cmp != NULL);

  g_list_free (cmp->items);
  cmp->items = NULL;
  g_list_free (cmp->cache);
  cmp->cache = NULL;
  g_free (cmp->prefix);
  cmp->prefix = NULL;
}

static void
completion_check_cache (Completion* cmp,
			gchar**	     new_prefix)
{
  register GList* list;
  register gsize len;
  register gsize i;
  register gsize plen;
  gchar* postfix;
  gchar* s;

  if (!new_prefix)
    return;
  if (!cmp->cache)
    {
      *new_prefix = NULL;
      return;
    }

  len = strlen(cmp->prefix);
  list = cmp->cache;
  s = cmp->func ? cmp->func (list->data) : (gchar*) list->data;
  postfix = s + len;
  plen = strlen (postfix);
  list = list->next;

  while (list && plen)
    {
      s = cmp->func ? cmp->func (list->data) : (gchar*) list->data;
      s += len;
      for (i = 0; i < plen; ++i)
	{
	  if (postfix[i] != s[i])
	    break;
	}
      plen = i;
      list = list->next;
    }

  *new_prefix = g_new0 (gchar, len + plen + 1);
  strncpy (*new_prefix, cmp->prefix, len);
  strncpy (*new_prefix + len, postfix, plen);
}

/**
 * completion_complete_utf8:
 * @cmp: the #Completion
 * @prefix: the prefix string, typically used by the user, which is compared
 *    with each of the items
 * @new_prefix: if non-%NULL, returns the longest prefix which is common to all
 *    items that matched @prefix, or %NULL if no items matched @prefix.
 *    This string should be freed when no longer needed.
 *
 * Attempts to complete the string @prefix using the #Completion target items.
 * In contrast to completion_complete(), this function returns the largest common
 * prefix that is a valid UTF-8 string, omitting a possible common partial
 * character.
 *
 * You should use this function instead of completion_complete() if your
 * items are UTF-8 strings.
 *
 * Return value: (element-type utf8) (transfer none): the list of items whose strings begin with @prefix. This should
 * not be changed.
 *
 * Since: 2.4
 *
 * Deprecated: 2.26: Rarely used API
 **/
GList*
completion_complete_utf8 (Completion  *cmp,
                          const gchar  *prefix,
                          gchar       **new_prefix)
{
  GList *list;
  gchar *p, *q;

  list = completion_complete (cmp, prefix, new_prefix);

  if (new_prefix && *new_prefix)
    {
      p = *new_prefix + strlen (*new_prefix);
      q = g_utf8_find_prev_char (*new_prefix, p);

      switch (g_utf8_get_char_validated (q, p - q))
	{
	case (gunichar)-2:
	case (gunichar)-1:
	  *q = 0;
	  break;
	default: ;
	}

    }

  return list;
}

/**
 * completion_complete:
 * @cmp: the #Completion.
 * @prefix: the prefix string, typically typed by the user, which is
 *          compared with each of the items.
 * @new_prefix: if non-%NULL, returns the longest prefix which is
 *              common to all items that matched @prefix, or %NULL if
 *              no items matched @prefix.  This string should be freed
 *              when no longer needed.
 *
 * Attempts to complete the string @prefix using the #Completion
 * target items.
 *
 * Returns: (transfer none): the list of items whose strings begin with
 *          @prefix. This should not be changed.
 *
 * Deprecated: 2.26: Rarely used API
 **/
GList*
completion_complete (Completion* cmp,
                     const gchar* prefix,
                     gchar**	    new_prefix)
{
  gsize plen, len;
  gboolean done = FALSE;
  GList* list;

  g_return_val_if_fail (cmp != NULL, NULL);
  g_return_val_if_fail (prefix != NULL, NULL);

  len = strlen (prefix);
  if (cmp->prefix && cmp->cache)
    {
      plen = strlen (cmp->prefix);
      if (plen <= len && ! cmp->strncmp_func (prefix, cmp->prefix, plen))
	{
	  /* use the cache */
	  list = cmp->cache;
	  while (list)
	    {
	      GList *next = list->next;

	      if (cmp->strncmp_func (prefix,
				     cmp->func ? cmp->func (list->data) : (gchar*) list->data,
				     len))
		cmp->cache = g_list_delete_link (cmp->cache, list);

	      list = next;
	    }
	  done = TRUE;
	}
    }

  if (!done)
    {
      /* normal code */
      g_list_free (cmp->cache);
      cmp->cache = NULL;
      list = cmp->items;
      while (*prefix && list)
	{
	  if (!cmp->strncmp_func (prefix,
                                  cmp->func ? cmp->func (list->data) : (gchar*) list->data,
                                  len))
	    cmp->cache = g_list_prepend (cmp->cache, list->data);
	  list = list->next;
	}
    }
  if (cmp->prefix)
    {
      g_free (cmp->prefix);
      cmp->prefix = NULL;
    }
  if (cmp->cache)
    cmp->prefix = g_strdup (prefix);
  completion_check_cache (cmp, new_prefix);

  return *prefix ? cmp->cache : cmp->items;
}

/**
 * completion_free:
 * @cmp: the #Completion.
 *
 * Frees all memory used by the #Completion. The items are not freed, so if
 * the memory was dynamically allocated, it should be freed after calling this
 * function.
 *
 * Deprecated: 2.26: Rarely used API
 **/
void
completion_free (Completion* cmp)
{
  g_return_if_fail (cmp != NULL);

  completion_clear_items (cmp);
  g_free (cmp);
}

/**
 * completion_set_compare:
 * @cmp: a #Completion.
 * @strncmp_func: the string comparison function.
 *
 * Sets the function to use for string comparisons. The default string
 * comparison function is strncmp().
 *
 * Deprecated: 2.26: Rarely used API
 **/
void
completion_set_compare(Completion *cmp,
                       CompletionStrncmpFunc strncmp_func)
{
  cmp->strncmp_func = strncmp_func;
}

#ifdef TEST_COMPLETION
#include <stdio.h>
int
main (int   argc,
      char* argv[])
{
  FILE *file;
  gchar buf[1024];
  GList *list;
  GList *result;
  GList *tmp;
  Completion *cmp;
  gint i;
  gchar *longp = NULL;

  if (argc < 3)
    {
      g_warning ("Usage: %s filename prefix1 [prefix2 ...]\n", argv[0]);
      return 1;
    }

  file = fopen (argv[1], "r");
  if (!file)
    {
      g_warning ("Cannot open %s\n", argv[1]);
      return 1;
    }

  cmp = completion_new (NULL);
  list = g_list_alloc ();
  while (fgets (buf, 1024, file))
    {
      list->data = g_strdup (buf);
      completion_add_items (cmp, list);
    }
  fclose (file);

  for (i = 2; i < argc; ++i)
    {
      printf ("COMPLETING: %s\n", argv[i]);
      result = completion_complete (cmp, argv[i], &longp);
      g_list_foreach (result, (GFunc) printf, NULL);
      printf ("LONG MATCH: %s\n", longp);
      g_free (longp);
      longp = NULL;
    }

  g_list_foreach (cmp->items, (GFunc) g_free, NULL);
  completion_free (cmp);
  g_list_free (list);

  return 0;
}

#endif