/*
 *   moocompletion.c
 *
 *   Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   See COPYING file that comes with this distribution.
 */

#include "mooedit/moocompletion.h"
#include "mooedit/mootextpopup.h"
#include "mooedit/mooedit-script.h"
#include "mooutils/moomarshals.h"
#include "mooutils/eggregex.h"
#include "mooscript/mooscript-parser.h"
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include <string.h>


#define COLUMN_DATA  MOO_COMPLETION_COLUMN_DATA
#define COLUMN_GROUP MOO_COMPLETION_COLUMN_GROUP

struct _MooCompletionPrivate {
    GtkListStore *store;
    GSList *groups;
    GSList *active_groups;
    GList *data;

    GtkTextView *doc;
    GtkTextBuffer *buffer;
    GtkTextMark *start;
    GtkTextMark *end;

    MooCompletionStringFunc string_func;
    MooCompletionFreeFunc free_func;
    MooCompletionCmpFunc cmp_func;

    MooTextPopup *popup;
    guint working : 1;
    guint in_update : 1;
};

struct _MooCompletionGroup {
    char *name;

    EggRegex *regex;
    guint *parens;
    guint n_parens;

    GCompletion *cmpl;
    GList *data;
    char *suffix;
    MSNode *script;

    MooCompletionFreeFunc free_func;
};


static void     moo_completion_dispose          (GObject            *object);

static void     moo_completion_update           (MooCompletion      *cmpl);
static void     moo_completion_populate         (MooCompletion      *cmpl,
                                                 const char         *text,
                                                 char              **prefix);
static void     moo_completion_complete         (MooCompletion      *cmpl,
                                                 GtkTreeModel       *model,
                                                 GtkTreeIter        *iter);

static void     moo_completion_connect_popup    (MooCompletion      *cmpl);
static void     moo_completion_disconnect_popup (MooCompletion      *cmpl);

static gboolean moo_completion_empty            (MooCompletion      *cmpl);
static gboolean moo_completion_unique           (MooCompletion      *cmpl,
                                                 GtkTreeIter        *iter);
static int      list_sort_func                  (GtkTreeModel       *model,
                                                 GtkTreeIter        *a,
                                                 GtkTreeIter        *b,
                                                 MooCompletion      *cmpl);

static MooCompletionGroup *moo_completion_group_new
                                                (const char         *name,
                                                 MooCompletionStringFunc string_func,
                                                 MooCompletionFreeFunc free_func);
static void     moo_completion_group_free       (MooCompletionGroup *group);

static gboolean moo_completion_group_find       (MooCompletionGroup *group,
                                                 const char         *line,
                                                 int                *start_pos,
                                                 int                *end_pos);
static GList   *moo_completion_group_complete   (MooCompletionGroup *group,
                                                 const char         *text,
                                                 char              **prefix);


G_DEFINE_TYPE (MooCompletion, moo_completion, G_TYPE_OBJECT)


static void
moo_completion_dispose (GObject *object)
{
    MooCompletion *cmpl = MOO_COMPLETION (object);

    if (cmpl->priv)
    {
        moo_completion_set_doc (cmpl, NULL);

        g_object_unref (cmpl->priv->store);
        g_slist_foreach (cmpl->priv->groups, (GFunc) moo_completion_group_free, NULL);
        g_slist_free (cmpl->priv->groups);
        g_slist_free (cmpl->priv->active_groups);

        if (cmpl->priv->popup)
        {
            moo_completion_disconnect_popup (cmpl);
            g_object_unref (cmpl->priv->popup);
        }

        g_free (cmpl->priv);
        cmpl->priv = NULL;
    }

    G_OBJECT_CLASS(moo_completion_parent_class)->dispose (object);
}


static void
moo_completion_class_init (MooCompletionClass *klass)
{
    G_OBJECT_CLASS(klass)->dispose = moo_completion_dispose;
}


static void
moo_completion_init (MooCompletion *cmpl)
{
    cmpl->priv = g_new0 (MooCompletionPrivate, 1);
    cmpl->priv->store = gtk_list_store_new (2, G_TYPE_POINTER,
                                            G_TYPE_POINTER);
    gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (cmpl->priv->store),
                                     COLUMN_DATA,
                                     (GtkTreeIterCompareFunc) list_sort_func,
                                     cmpl, NULL);
    cmpl->priv->popup = moo_text_popup_new (NULL);
    moo_completion_connect_popup (cmpl);
}


void
moo_completion_try_complete (MooCompletion *cmpl,
                             gboolean       insert_unique)
{
    GSList *l;
    GtkTextIter start, end;
    GtkTreeIter iter;
    gboolean found = FALSE;
    int start_pos = -1, end_pos = -1;
    char *prefix = NULL, *text = NULL, *line;

    g_return_if_fail (MOO_IS_COMPLETION (cmpl));
    g_return_if_fail (cmpl->priv->buffer != NULL);
    g_return_if_fail (!cmpl->priv->working);

    cmpl->priv->working = TRUE;

    gtk_text_buffer_get_iter_at_mark (cmpl->priv->buffer, &end,
                                      gtk_text_buffer_get_insert (cmpl->priv->buffer));
    start = end;

    if (!gtk_text_iter_starts_line (&start))
        gtk_text_iter_set_line_offset (&start, 0);

    line = gtk_text_buffer_get_slice (cmpl->priv->buffer, &start, &end, TRUE);

    for (l = cmpl->priv->groups; l != NULL; l = l->next)
    {
        int start_pos_here, end_pos_here;
        MooCompletionGroup *grp = l->data;

        if (!moo_completion_group_find (grp, line, &start_pos_here, &end_pos_here))
            continue;

        if (!found)
        {
            found = TRUE;
            start_pos = start_pos_here;
            end_pos = end_pos_here;
        }

        if (start_pos_here == start_pos && end_pos_here == end_pos)
            cmpl->priv->active_groups =
                    g_slist_prepend (cmpl->priv->active_groups, grp);
    }

    if (found)
    {
        cmpl->priv->active_groups = g_slist_reverse (cmpl->priv->active_groups);

        gtk_text_iter_set_line_index (&start, start_pos);
        gtk_text_iter_set_line_index (&end, end_pos);

        text = gtk_text_buffer_get_slice (cmpl->priv->buffer, &start, &end, TRUE);
        moo_completion_set_region (cmpl, &start, &end);
        moo_completion_populate (cmpl, text, &prefix);
    }

    if (!found || moo_completion_empty (cmpl))
    {
        g_slist_free (cmpl->priv->active_groups);
        cmpl->priv->active_groups = NULL;
        cmpl->priv->working = FALSE;
        goto out;
    }

    if (insert_unique && moo_completion_unique (cmpl, &iter))
    {
        moo_completion_complete (cmpl, GTK_TREE_MODEL (cmpl->priv->store), &iter);
        cmpl->priv->working = FALSE;
        goto out;
    }

    if (prefix && strcmp (text, prefix))
    {
        gtk_text_buffer_begin_user_action (cmpl->priv->buffer);
        gtk_text_buffer_delete (cmpl->priv->buffer, &start, &end);
        gtk_text_buffer_insert (cmpl->priv->buffer, &start, prefix, -1);
        gtk_text_buffer_end_user_action (cmpl->priv->buffer);
    }

    moo_completion_get_region (cmpl, &start, NULL);
    moo_text_popup_show (cmpl->priv->popup, &start);

out:
    g_free (text);
    g_free (prefix);
    g_free (line);
}


static void
moo_completion_update (MooCompletion *cmpl)
{
    GtkTextIter start, end;
    char *text;

    g_return_if_fail (cmpl->priv->working);
    g_return_if_fail (cmpl->priv->active_groups != NULL);

    moo_completion_get_region (cmpl, &start, &end);
    text = gtk_text_buffer_get_slice (cmpl->priv->buffer, &start, &end, TRUE);

    moo_completion_populate (cmpl, text, NULL);

    if (!moo_completion_empty (cmpl))
        moo_text_popup_update (cmpl->priv->popup);
    else
        moo_completion_hide (cmpl);

    g_free (text);
}


static int
list_sort_func (GtkTreeModel       *model,
                GtkTreeIter        *a,
                GtkTreeIter        *b,
                MooCompletion      *cmpl)
{
    gpointer data1, data2;

    g_assert (MOO_IS_COMPLETION (cmpl));
    g_assert (model == GTK_TREE_MODEL (cmpl->priv->store));
    g_assert (cmpl->priv->cmp_func != NULL);

    gtk_tree_model_get (model, a, COLUMN_DATA, &data1, -1);
    gtk_tree_model_get (model, b, COLUMN_DATA, &data2, -1);

    return cmpl->priv->cmp_func (data1, data2);
}


static void
moo_completion_exec_script (MooCompletion      *cmpl,
                            MooCompletionGroup *group,
                            GtkTextIter        *start,
                            GtkTextIter        *end,
                            const char         *completion)
{
    MSContext *ctx;
    char *match;
    MSValue *result;

    if (MOO_IS_EDIT (cmpl->priv->doc))
        ctx = moo_edit_context_new (MOO_EDIT (cmpl->priv->doc), NULL);
    else
        ctx = moo_text_context_new (cmpl->priv->doc);

    match = gtk_text_buffer_get_slice (cmpl->priv->buffer, start, end, TRUE);

    ms_context_assign_string (ctx, MOO_COMPLETION_VAR_MATCH, match);
    ms_context_assign_string (ctx, MOO_COMPLETION_VAR_COMPLETION, completion);

    gtk_text_buffer_delete (cmpl->priv->buffer, start, end);
    gtk_text_buffer_place_cursor (cmpl->priv->buffer, start);
    result = ms_top_node_eval (group->script, ctx);

    if (result)
        ms_value_unref (result);
    else
        g_warning ("%s: %s", G_STRLOC,
                   ms_context_get_error_msg (ctx));

    g_free (match);
    g_object_unref (ctx);
}


static void
moo_completion_complete (MooCompletion *cmpl,
                         GtkTreeModel  *model,
                         GtkTreeIter   *iter)
{
    char *text, *old_text;
    GtkTextIter start, end;
    gpointer data = NULL;
    MooCompletionGroup *group = NULL;
    gboolean set_cursor = FALSE;

    g_return_if_fail (cmpl->priv->active_groups != NULL);

    gtk_tree_model_get (model, iter, COLUMN_DATA, &data, COLUMN_GROUP, &group, -1);
    g_assert (group != NULL);

    text = cmpl->priv->string_func ? cmpl->priv->string_func (data) : data;
    g_return_if_fail (text != NULL);

    moo_completion_get_region (cmpl, &start, &end);
    old_text = gtk_text_buffer_get_slice (cmpl->priv->buffer,
                                          &start, &end, TRUE);

    gtk_text_buffer_begin_user_action (cmpl->priv->buffer);

    if (group->script)
    {
        moo_completion_exec_script (cmpl, group, &start, &end, text);
    }
    else
    {
        if (strcmp (text, old_text))
        {
            gtk_text_buffer_delete (cmpl->priv->buffer, &start, &end);
            gtk_text_buffer_insert (cmpl->priv->buffer, &start, text, -1);
            set_cursor = TRUE;
        }

        if (group->suffix)
        {
            gboolean do_insert = TRUE;

            if (!gtk_text_iter_ends_line (&start))
            {
                char *old_suffix;
                end = start;
                gtk_text_iter_forward_to_line_end (&end);
                old_suffix = gtk_text_buffer_get_slice (cmpl->priv->buffer, &start, &end, TRUE);
                if (!strncmp (group->suffix, old_suffix, strlen (group->suffix)))
                    do_insert = FALSE;
                g_free (old_suffix);
            }

            if (do_insert)
            {
                gtk_text_buffer_insert (cmpl->priv->buffer, &start, group->suffix, -1);
                set_cursor = TRUE;
            }
        }
    }

    if (set_cursor)
        gtk_text_buffer_place_cursor (cmpl->priv->buffer, &start);

    gtk_text_buffer_end_user_action (cmpl->priv->buffer);

    moo_completion_hide (cmpl);

    g_free (old_text);
}


static char *
find_common_prefix (GSList *list)
{
    char *prefix = NULL;
    guint prefix_len = 0;

    g_return_val_if_fail (list != NULL, NULL);

    while (list)
    {
        char *s = list->data;

        if (!prefix)
        {
            prefix_len = strlen (s);
            prefix = g_strndup (s, prefix_len);
        }
        else
        {
            guint i;

            for (i = 0; i < prefix_len; ++i)
            {
                if (prefix[i] != s[i])
                    break;
            }

            if (i < prefix_len)
                prefix_len = i;
        }

        if (!prefix_len)
            break;

        list = list->next;
    }

    prefix[prefix_len] = 0;
    return prefix;
}


static void
moo_completion_populate (MooCompletion      *cmpl,
                         const char         *text,
                         char              **prefix)
{
    GSList *l;
    GSList *prefixes = NULL;

    gtk_list_store_clear (cmpl->priv->store);
    gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (cmpl->priv->store),
                                          GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
                                          GTK_SORT_ASCENDING);

    for (l = cmpl->priv->active_groups; l != NULL; l = l->next)
    {
        char *new_prefix = NULL;
        MooCompletionGroup *group = l->data;

        GList *list = moo_completion_group_complete (group, text,
                                                     prefix ? &new_prefix : NULL);

        if (prefix && list)
        {
            if (!new_prefix)
                new_prefix = g_strdup (text);
            prefixes = g_slist_prepend (prefixes, new_prefix);
        }

        while (list)
        {
            GtkTreeIter iter;
            gtk_list_store_append (cmpl->priv->store, &iter);
            gtk_list_store_set (cmpl->priv->store, &iter,
                                COLUMN_DATA, list->data,
                                COLUMN_GROUP, group,
                                -1);
            list = list->next;
        }
    }

    if (cmpl->priv->cmp_func)
        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (cmpl->priv->store),
                                              COLUMN_DATA, GTK_SORT_ASCENDING);

    if (prefix && prefixes)
    {
        if (prefixes->next)
        {
            *prefix = find_common_prefix (prefixes);
            g_slist_foreach (prefixes, (GFunc) g_free, NULL);
            g_slist_free (prefixes);
        }
        else
        {
            *prefix = prefixes->data;
            g_slist_free (prefixes);
        }
    }
}


static gboolean
moo_completion_empty (MooCompletion *cmpl)
{
    return !gtk_tree_model_iter_n_children (GTK_TREE_MODEL (cmpl->priv->store), NULL);
}


static gboolean
moo_completion_unique (MooCompletion  *cmpl,
                       GtkTreeIter    *iter)
{
    return gtk_tree_model_iter_n_children (GTK_TREE_MODEL (cmpl->priv->store), NULL) == 1 &&
            gtk_tree_model_get_iter_first (GTK_TREE_MODEL (cmpl->priv->store), iter);
}


static void
on_popup_activate (MooCompletion    *cmpl,
                   GtkTreeModel     *model,
                   GtkTreeIter      *iter)
{
    moo_completion_complete (cmpl, model, iter);
}


static void
moo_completion_connect_popup (MooCompletion *cmpl)
{
    moo_text_popup_set_model (cmpl->priv->popup,
                              GTK_TREE_MODEL (cmpl->priv->store));
    g_signal_connect_swapped (cmpl->priv->popup, "activate",
                              G_CALLBACK (on_popup_activate), cmpl);
    g_signal_connect_swapped (cmpl->priv->popup, "text-changed",
                              G_CALLBACK (moo_completion_update), cmpl);
    g_signal_connect_swapped (cmpl->priv->popup, "hide",
                              G_CALLBACK (moo_completion_hide), cmpl);
}


static void
moo_completion_disconnect_popup (MooCompletion *cmpl)
{
    moo_text_popup_set_model (cmpl->priv->popup, NULL);
    g_signal_handlers_disconnect_by_func (cmpl->priv->popup,
                                          (gpointer) on_popup_activate,
                                          cmpl);
    g_signal_handlers_disconnect_by_func (cmpl->priv->popup,
                                          (gpointer) moo_completion_update,
                                          cmpl);
    g_signal_handlers_disconnect_by_func (cmpl->priv->popup,
                                          (gpointer) moo_completion_hide,
                                          cmpl);
}


void
moo_completion_hide (MooCompletion *cmpl)
{
    g_return_if_fail (MOO_IS_COMPLETION (cmpl));

    if (cmpl->priv->working)
    {
        cmpl->priv->working = FALSE;
        moo_text_popup_hide (cmpl->priv->popup);
        gtk_list_store_clear (cmpl->priv->store);
        g_slist_free (cmpl->priv->active_groups);
        cmpl->priv->active_groups = NULL;
    }
}


void
moo_completion_set_doc (MooCompletion  *cmpl,
                             GtkTextView        *doc)
{
    g_return_if_fail (MOO_IS_COMPLETION (cmpl));
    g_return_if_fail (!doc || GTK_IS_TEXT_VIEW (doc));

    if (cmpl->priv->doc == doc)
        return;

    moo_completion_hide (cmpl);

    if (cmpl->priv->doc)
    {
        if (cmpl->priv->start)
            gtk_text_buffer_delete_mark (cmpl->priv->buffer, cmpl->priv->start);
        if (cmpl->priv->end)
            gtk_text_buffer_delete_mark (cmpl->priv->buffer, cmpl->priv->end);
        g_object_unref (cmpl->priv->buffer);
        g_object_unref (cmpl->priv->doc);
        cmpl->priv->start = cmpl->priv->end = NULL;
        cmpl->priv->buffer = NULL;
        cmpl->priv->doc = NULL;
    }

    if (doc)
    {
        cmpl->priv->doc = g_object_ref (doc);
        cmpl->priv->buffer = g_object_ref (gtk_text_view_get_buffer (doc));
    }

    moo_text_popup_set_doc (cmpl->priv->popup, doc);
}


GtkTextView *
moo_completion_get_doc (MooCompletion *cmpl)
{
    g_return_val_if_fail (MOO_IS_COMPLETION (cmpl), NULL);
    return cmpl->priv->doc;
}


MooTextPopup *
moo_completion_get_popup (MooCompletion *cmpl)
{
    g_return_val_if_fail (MOO_IS_COMPLETION (cmpl), NULL);
    return cmpl->priv->popup;
}


gboolean
moo_completion_get_region (MooCompletion  *cmpl,
                                GtkTextIter        *start,
                                GtkTextIter        *end)
{
    g_return_val_if_fail (MOO_IS_COMPLETION (cmpl), FALSE);

    if (cmpl->priv->start)
    {
        if (start)
            gtk_text_buffer_get_iter_at_mark (cmpl->priv->buffer, start,
                                              cmpl->priv->start);
        if (end)
            gtk_text_buffer_get_iter_at_mark (cmpl->priv->buffer, end,
                                              cmpl->priv->end);
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


void
moo_completion_set_region (MooCompletion      *cmpl,
                           const GtkTextIter  *start,
                           const GtkTextIter  *end)
{
    g_return_if_fail (MOO_IS_COMPLETION (cmpl));
    g_return_if_fail (start && end);
    g_return_if_fail (cmpl->priv->buffer != NULL);

    if (!cmpl->priv->start)
    {
        cmpl->priv->start = gtk_text_buffer_create_mark (cmpl->priv->buffer, NULL, start, TRUE);
        cmpl->priv->end = gtk_text_buffer_create_mark (cmpl->priv->buffer, NULL, end, FALSE);
    }
    else
    {
        gtk_text_buffer_move_mark (cmpl->priv->buffer, cmpl->priv->start, start);
        gtk_text_buffer_move_mark (cmpl->priv->buffer, cmpl->priv->end, end);
    }

    moo_text_popup_set_position (cmpl->priv->popup, start);
    moo_completion_update (cmpl);
}


MooCompletion *
moo_completion_new (MooCompletionStringFunc string_func,
                    MooCompletionFreeFunc free_func,
                    MooCompletionCmpFunc cmp_func)
{
    MooCompletion *cmpl = g_object_new (MOO_TYPE_COMPLETION, NULL);

    cmpl->priv->string_func = string_func;
    cmpl->priv->free_func = free_func;
    cmpl->priv->cmp_func = cmp_func;

    return cmpl;
}


static void
text_cell_data_func (G_GNUC_UNUSED GtkTreeViewColumn *tree_column,
                     GtkCellRenderer    *cell,
                     GtkTreeModel       *tree_model,
                     GtkTreeIter        *iter,
                     MooCompletion      *cmpl)
{
    gpointer data = NULL;
    char *text;

    g_assert (MOO_IS_COMPLETION (cmpl));

    gtk_tree_model_get (tree_model, iter, 0, &data, -1);
    text = cmpl->priv->string_func ? cmpl->priv->string_func (data) : data;
    g_return_if_fail (text != NULL);

    g_object_set (cell, "text", text, NULL);
}


MooCompletion *
moo_completion_new_text (GList *words)
{
    MooCompletion *cmpl;
    GtkCellRenderer *cell;

    cmpl = moo_completion_new (NULL, g_free, (MooCompletionCmpFunc) strcmp);

    if (words)
    {
        MooCompletionGroup *group = moo_completion_new_group (cmpl, NULL);
        moo_completion_group_add_data (group, words);
        moo_completion_group_set_pattern (group, "\\w*", NULL, 0);
    }

    cell = gtk_cell_renderer_text_new ();
    gtk_tree_view_column_pack_start (cmpl->priv->popup->column, cell, TRUE);
    gtk_tree_view_column_set_cell_data_func (cmpl->priv->popup->column, cell,
                                             (GtkTreeCellDataFunc) text_cell_data_func,
                                             g_object_ref (cmpl),
                                             g_object_unref);

    return cmpl;
}


MooCompletionGroup *
moo_completion_new_group (MooCompletion *cmpl,
                          const char    *name)
{
    MooCompletionGroup *group;

    g_return_val_if_fail (MOO_IS_COMPLETION (cmpl), NULL);

    group = moo_completion_group_new (name,
                                      cmpl->priv->string_func,
                                      cmpl->priv->free_func);
    cmpl->priv->groups = g_slist_append (cmpl->priv->groups, group);

    return group;
}


/****************************************************************************/
/* MooCompletionGroup
 */

MooCompletionGroup *
moo_completion_group_new (const char *name,
                          MooCompletionStringFunc string_func,
                          MooCompletionFreeFunc free_func)
{
    MooCompletionGroup *group = g_new0 (MooCompletionGroup, 1);
    group->cmpl = g_completion_new (string_func);
    group->free_func = free_func;
    group->name = g_strdup (name);
    return group;
}


void
moo_completion_group_set_data (MooCompletionGroup *group,
                               GList              *data)
{
    g_return_if_fail (group != NULL);

    g_completion_clear_items (group->cmpl);

    if (group->free_func)
        g_list_foreach (group->data, (GFunc) group->free_func, NULL);
    g_list_free (group->data);

    group->data = data;
    g_completion_add_items (group->cmpl, group->data);
}


void
moo_completion_group_add_data (MooCompletionGroup *group,
                               GList              *data)
{
    g_return_if_fail (group != NULL);

    if (!data)
        return;

    g_completion_clear_items (group->cmpl);
    group->data = g_list_concat (group->data, data);
    g_completion_add_items (group->cmpl, group->data);
}


static gboolean
moo_completion_group_find (MooCompletionGroup *group,
                           const char         *line,
                           int                *start_pos_p,
                           int                *end_pos_p)
{
    g_return_val_if_fail (group != NULL, FALSE);
    g_return_val_if_fail (line != NULL, FALSE);
    g_return_val_if_fail (group->regex != NULL, FALSE);

    egg_regex_clear (group->regex);

    if (egg_regex_match (group->regex, line, -1, 0) >= 1)
    {
        guint i;

        for (i = 0; i < group->n_parens; ++i)
        {
            int start_pos = -1, end_pos = -1;

            egg_regex_fetch_pos (group->regex, line, group->parens[i],
                                 &start_pos, &end_pos);

            if (start_pos >= 0 && end_pos >= 0)
            {
                if (start_pos_p)
                    *start_pos_p = start_pos;
                if (end_pos_p)
                    *end_pos_p = end_pos;
                return TRUE;
            }
        }
    }

    return FALSE;
}


static GList *
moo_completion_group_complete (MooCompletionGroup *group,
                               const char         *text,
                               char              **prefix)
{
    char *dummy = NULL;
    GList *list;

    if (!prefix)
        prefix = &dummy;

    /* g_completion_complete_utf8 wants prefix != NULL */
    list = g_completion_complete_utf8 (group->cmpl, text, prefix);

    g_free (dummy);
    return list;
}


void
moo_completion_group_set_pattern (MooCompletionGroup *group,
                                  const char         *pattern,
                                  const guint        *parens,
                                  guint               n_parens)
{
    EggRegex *regex;
    GError *error = NULL;
    char *real_pattern;

    g_return_if_fail (group != NULL);
    g_return_if_fail (pattern && pattern[0]);
    g_return_if_fail (!parens || n_parens);

    real_pattern = g_strdup_printf ("%s$", pattern);
    regex = egg_regex_new (real_pattern, 0, 0, &error);

    if (!regex)
    {
        g_warning ("%s: %s", G_STRLOC, error->message);
        goto err;
    }

    egg_regex_optimize (regex, &error);

    if (error)
    {
        g_warning ("%s: %s", G_STRLOC, error->message);
        g_error_free (error);
    }

    egg_regex_unref (group->regex);
    group->regex = regex;

    g_free (group->parens);

    if (!parens)
    {
        group->parens = g_new0 (guint, 1);
        group->n_parens = 1;
    }
    else
    {
        group->parens = g_memdup (parens, n_parens * sizeof (guint));
        group->n_parens = n_parens;
    }

    g_free (real_pattern);
    return;

err:
    if (error)
        g_error_free (error);
    g_free (real_pattern);
    egg_regex_unref (regex);
}


void
moo_completion_group_set_suffix (MooCompletionGroup *group,
                                 const char         *suffix)
{
    g_return_if_fail (group != NULL);

    if (group->suffix != suffix)
    {
        g_free (group->suffix);
        group->suffix = (suffix && suffix[0]) ? g_strdup (suffix) : NULL;
    }
}


void
moo_completion_group_set_script (MooCompletionGroup *group,
                                 const char         *script)
{
    g_return_if_fail (group != NULL);

    if (group->script)
    {
        ms_node_unref (group->script);
        group->script = NULL;
    }

    if (script)
        group->script = ms_script_parse (script);
}


const char *
moo_completion_group_get_name (MooCompletionGroup *group)
{
    g_return_val_if_fail (group != NULL, NULL);
    return group->name;
}


GType
moo_completion_group_get_type (void)
{
    static GType type;

    if (!type)
        type = g_pointer_type_register_static ("MooCompletionGroup");

    return type;
}


static void
moo_completion_group_free (MooCompletionGroup *group)
{
    g_return_if_fail (group != NULL);

    egg_regex_unref (group->regex);
    g_free (group->parens);
    g_completion_free (group->cmpl);
    g_free (group->suffix);
    g_free (group->name);

    if (group->script)
        ms_node_unref (group->script);

    if (group->free_func)
        g_list_foreach (group->data, (GFunc) group->free_func, NULL);
    g_list_free (group->data);

    g_free (group);
}