/* GIO - GLib Input, Output and Streaming Library

 * 

 * Copyright (C) 2006-2007 Red Hat, Inc.

 *

 * 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.1 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, see <http://www.gnu.org/licenses/>.

 *

 * Author: Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include "gfilenamecompleter.h"

#include "gfileenumerator.h"

#include "gfileattribute.h"

#include "gfile.h"

#include "gfileinfo.h"

#include "gcancellable.h"

#include <string.h>

#include "glibintl.h"

/**

 * SECTION:gfilenamecompleter

 * @short_description: Filename Completer

 * @include: gio/gio.h

 * 

 * Completes partial file and directory names given a partial string by

 * looking in the file system for clues. Can return a list of possible 

 * completion strings for widget implementations.

 * 

 **/

enum {

  GOT_COMPLETION_DATA,

  LAST_SIGNAL

};

static guint signals[LAST_SIGNAL] = { 0 };

typedef struct {

  GFilenameCompleter *completer;

  GFileEnumerator *enumerator;

  GCancellable *cancellable;

  gboolean should_escape;

  GFile *dir;

  GList *basenames;

  gboolean dirs_only;

} LoadBasenamesData;

struct _GFilenameCompleter {

  GObject parent;

  GFile *basenames_dir;

  gboolean basenames_are_escaped;

  gboolean dirs_only;

  GList *basenames;

  LoadBasenamesData *basename_loader;

};

G_DEFINE_TYPE (GFilenameCompleter, g_filename_completer, G_TYPE_OBJECT)

static void cancel_load_basenames (GFilenameCompleter *completer);

static void

g_filename_completer_finalize (GObject *object)

{

  GFilenameCompleter *completer;

  completer = G_FILENAME_COMPLETER (object);

  cancel_load_basenames (completer);

  if (completer->basenames_dir)

    g_object_unref (completer->basenames_dir);

  g_list_free_full (completer->basenames, g_free);

  G_OBJECT_CLASS (g_filename_completer_parent_class)->finalize (object);

}

static void

g_filename_completer_class_init (GFilenameCompleterClass *klass)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->finalize = g_filename_completer_finalize;

  /**

   * GFilenameCompleter::got-completion-data:

   * 

   * Emitted when the file name completion information comes available.

   **/

  signals[GOT_COMPLETION_DATA] = g_signal_new (I_("got-completion-data"),

					  G_TYPE_FILENAME_COMPLETER,

					  G_SIGNAL_RUN_LAST,

					  G_STRUCT_OFFSET (GFilenameCompleterClass, got_completion_data),

					  NULL, NULL,

					  g_cclosure_marshal_VOID__VOID,

					  G_TYPE_NONE, 0);

}

static void

g_filename_completer_init (GFilenameCompleter *completer)

{

}

/**

 * g_filename_completer_new:

 * 

 * Creates a new filename completer.

 * 

 * Returns: a #GFilenameCompleter.

 **/

GFilenameCompleter *

g_filename_completer_new (void)

{

  return g_object_new (G_TYPE_FILENAME_COMPLETER, NULL);

}

static char *

longest_common_prefix (char *a, char *b)

{

  char *start;

  start = a;

  while (g_utf8_get_char (a) == g_utf8_get_char (b))

    {

      a = g_utf8_next_char (a);

      b = g_utf8_next_char (b);

    }

  return g_strndup (start, a - start);

}

static void

load_basenames_data_free (LoadBasenamesData *data)

{

  if (data->enumerator)

    g_object_unref (data->enumerator);

  g_object_unref (data->cancellable);

  g_object_unref (data->dir);

  g_list_free_full (data->basenames, g_free);

  g_free (data);

}

static void

got_more_files (GObject *source_object,

		GAsyncResult *res,

		gpointer user_data)

{

  LoadBasenamesData *data = user_data;

  GList *infos, *l;

  GFileInfo *info;

  const char *name;

  gboolean append_slash;

  char *t;

  char *basename;

  if (data->completer == NULL)

    {

      /* Was cancelled */

      load_basenames_data_free (data);

      return;

    }

  infos = g_file_enumerator_next_files_finish (data->enumerator, res, NULL);

  for (l = infos; l != NULL; l = l->next)

    {

      info = l->data;

      if (data->dirs_only &&

	  g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)

	{

	  g_object_unref (info);

	  continue;

	}

      append_slash = g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY;

      name = g_file_info_get_name (info);

      if (name == NULL)

	{

	  g_object_unref (info);

	  continue;

	}

      if (data->should_escape)

	basename = g_uri_escape_string (name,

					G_URI_RESERVED_CHARS_ALLOWED_IN_PATH,

					TRUE);

      else

	/* If not should_escape, must be a local filename, convert to utf8 */

	basename = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);

      if (basename)

	{

	  if (append_slash)

	    {

	      t = basename;

	      basename = g_strconcat (basename, "/", NULL);

	      g_free (t);

	    }

	  data->basenames = g_list_prepend (data->basenames, basename);

	}

      g_object_unref (info);

    }

  g_list_free (infos);

  if (infos)

    {

      /* Not last, get more files */

      g_file_enumerator_next_files_async (data->enumerator,

					  100,

					  0,

					  data->cancellable,

					  got_more_files, data);

    }

  else

    {

      data->completer->basename_loader = NULL;

      if (data->completer->basenames_dir)

	g_object_unref (data->completer->basenames_dir);

      g_list_free_full (data->completer->basenames, g_free);

      data->completer->basenames_dir = g_object_ref (data->dir);

      data->completer->basenames = data->basenames;

      data->completer->basenames_are_escaped = data->should_escape;

      data->basenames = NULL;

      g_file_enumerator_close_async (data->enumerator, 0, NULL, NULL, NULL);

      g_signal_emit (data->completer, signals[GOT_COMPLETION_DATA], 0);

      load_basenames_data_free (data);

    }

}

static void

got_enum (GObject *source_object,

	  GAsyncResult *res,

	  gpointer user_data)

{

  LoadBasenamesData *data = user_data;

  if (data->completer == NULL)

    {

      /* Was cancelled */

      load_basenames_data_free (data);

      return;

    }

  data->enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, NULL);

  if (data->enumerator == NULL)

    {

      data->completer->basename_loader = NULL;

      if (data->completer->basenames_dir)

	g_object_unref (data->completer->basenames_dir);

      g_list_free_full (data->completer->basenames, g_free);

      /* Mark uptodate with no basenames */

      data->completer->basenames_dir = g_object_ref (data->dir);

      data->completer->basenames = NULL;

      data->completer->basenames_are_escaped = data->should_escape;

      load_basenames_data_free (data);

      return;

    }

  g_file_enumerator_next_files_async (data->enumerator,

				      100,

				      0,

				      data->cancellable,

				      got_more_files, data);

}

static void

schedule_load_basenames (GFilenameCompleter *completer,

			 GFile *dir,

			 gboolean should_escape)

{

  LoadBasenamesData *data;

  cancel_load_basenames (completer);

  data = g_new0 (LoadBasenamesData, 1);

  data->completer = completer;

  data->cancellable = g_cancellable_new ();

  data->dir = g_object_ref (dir);

  data->should_escape = should_escape;

  data->dirs_only = completer->dirs_only;

  completer->basename_loader = data;

  g_file_enumerate_children_async (dir,

				   G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE,

				   0, 0,

				   data->cancellable,

				   got_enum, data);

}

static void

cancel_load_basenames (GFilenameCompleter *completer)

{

  LoadBasenamesData *loader;

  if (completer->basename_loader)

    {

      loader = completer->basename_loader; 

      loader->completer = NULL;

      g_cancellable_cancel (loader->cancellable);

      completer->basename_loader = NULL;

    }

}

/* Returns a list of possible matches and the basename to use for it */

static GList *

init_completion (GFilenameCompleter *completer,

		 const char *initial_text,

		 char **basename_out)

{

  gboolean should_escape;

  GFile *file, *parent;

  char *basename;

  char *t;

  int len;

  *basename_out = NULL;

  should_escape = ! (g_path_is_absolute (initial_text) || *initial_text == '~');

  len = strlen (initial_text);

  if (len > 0 &&

      initial_text[len - 1] == '/')

    return NULL;

  file = g_file_parse_name (initial_text);

  parent = g_file_get_parent (file);

  if (parent == NULL)

    {

      g_object_unref (file);

      return NULL;

    }

  if (completer->basenames_dir == NULL ||

      completer->basenames_are_escaped != should_escape ||

      !g_file_equal (parent, completer->basenames_dir))

    {

      schedule_load_basenames (completer, parent, should_escape);

      g_object_unref (file);

      return NULL;

    }

  basename = g_file_get_basename (file);

  if (should_escape)

    {

      t = basename;

      basename = g_uri_escape_string (basename, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);

      g_free (t);

    }

  else

    {

      t = basename;

      basename = g_filename_to_utf8 (basename, -1, NULL, NULL, NULL);

      g_free (t);

      if (basename == NULL)

	return NULL;

    }

  *basename_out = basename;

  return completer->basenames;

}

/**

 * g_filename_completer_get_completion_suffix:

 * @completer: the filename completer.

 * @initial_text: text to be completed.

 *

 * Obtains a completion for @initial_text from @completer.

 *  

 * Returns: a completed string, or %NULL if no completion exists. 

 *     This string is not owned by GIO, so remember to g_free() it 

 *     when finished.

 **/

char *

g_filename_completer_get_completion_suffix (GFilenameCompleter *completer,

					    const char *initial_text)

{

  GList *possible_matches, *l;

  char *prefix;

  char *suffix;

  char *possible_match;

  char *lcp;

  g_return_val_if_fail (G_IS_FILENAME_COMPLETER (completer), NULL);

  g_return_val_if_fail (initial_text != NULL, NULL);

  possible_matches = init_completion (completer, initial_text, &prefix);

  suffix = NULL;

  for (l = possible_matches; l != NULL; l = l->next)

    {

      possible_match = l->data;

      if (g_str_has_prefix (possible_match, prefix))

	{

	  if (suffix == NULL)

	    suffix = g_strdup (possible_match + strlen (prefix));

	  else

	    {

	      lcp = longest_common_prefix (suffix,

					   possible_match + strlen (prefix));

	      g_free (suffix);

	      suffix = lcp;

	      if (*suffix == 0)

		break;

	    }

	}

    }

  g_free (prefix);

  return suffix;

}

/**

 * g_filename_completer_get_completions:

 * @completer: the filename completer.

 * @initial_text: text to be completed.

 * 

 * Gets an array of completion strings for a given initial text.

 * 

 * Returns: (array zero-terminated=1) (transfer full): array of strings with possible completions for @initial_text.

 * This array must be freed by g_strfreev() when finished. 

 **/

char **

g_filename_completer_get_completions (GFilenameCompleter *completer,

				      const char         *initial_text)

{

  GList *possible_matches, *l;

  char *prefix;

  char *possible_match;

  GPtrArray *res;

  g_return_val_if_fail (G_IS_FILENAME_COMPLETER (completer), NULL);

  g_return_val_if_fail (initial_text != NULL, NULL);

  possible_matches = init_completion (completer, initial_text, &prefix);

  res = g_ptr_array_new ();

  for (l = possible_matches; l != NULL; l = l->next)

    {

      possible_match = l->data;

      if (g_str_has_prefix (possible_match, prefix))

	g_ptr_array_add (res,

			 g_strconcat (initial_text, possible_match + strlen (prefix), NULL));

    }

  g_free (prefix);

  g_ptr_array_add (res, NULL);

  return (char**)g_ptr_array_free (res, FALSE);

}

/**

 * g_filename_completer_set_dirs_only:

 * @completer: the filename completer.

 * @dirs_only: a #gboolean.

 * 

 * If @dirs_only is %TRUE, @completer will only 

 * complete directory names, and not file names.

 **/

void

g_filename_completer_set_dirs_only (GFilenameCompleter *completer,

				    gboolean dirs_only)

{

  g_return_if_fail (G_IS_FILENAME_COMPLETER (completer));

  completer->dirs_only = dirs_only;

}