/*
 * glade-adaptor-chooser-widget.c
 *
 * Copyright (C) 2014-2017 Juan Pablo Ugarte
 *
 * 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 program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Authors:
 *   Juan Pablo Ugarte <juanpablougarte@gmail.com>
 */

#include "glade-app.h"
#include "gladeui-enum-types.h"
#include "glade-adaptor-chooser-widget.h"
#include "glade-dnd.h"

#include <string.h>

enum
{
  COLUMN_ADAPTOR = 0,
  COLUMN_GROUP,
  COLUMN_NORMALIZED_NAME,
  COLUMN_NORMALIZED_NAME_LEN,
  N_COLUMN
};

struct _GladeAdaptorChooserWidgetPrivate
{
  GtkTreeView        *treeview;
  GtkListStore       *store;
  GtkTreeModelFilter *treemodelfilter;
  GtkSearchEntry     *searchentry;
  GtkEntryCompletion *entrycompletion;
  GtkScrolledWindow  *scrolledwindow;

  /* Needed for gtk_tree_view_column_set_cell_data_func() */
  GtkTreeViewColumn *column_icon;
  GtkCellRenderer   *icon_cell;
  GtkTreeViewColumn *column_adaptor;
  GtkCellRenderer   *adaptor_cell;

  /* Properties */
  _GladeAdaptorChooserWidgetFlags flags;
  GladeProject *project;
  gboolean show_group_title;
  gchar *search_text;
};

enum
{
  PROP_0,

  PROP_SHOW_FLAGS,
  PROP_PROJECT,
  PROP_SHOW_GROUP_TITLE
};

enum
{
  ADAPTOR_SELECTED,

  LAST_SIGNAL
};

static guint adaptor_chooser_signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE_WITH_PRIVATE (_GladeAdaptorChooserWidget, _glade_adaptor_chooser_widget, GTK_TYPE_BOX);

#define GET_PRIVATE(d) ((_GladeAdaptorChooserWidgetPrivate *) _glade_adaptor_chooser_widget_get_instance_private((_GladeAdaptorChooserWidget*)d))

static void
_glade_adaptor_chooser_widget_init (_GladeAdaptorChooserWidget *chooser)
{
  gtk_widget_init_template (GTK_WIDGET (chooser));
}

static void
_glade_adaptor_chooser_widget_finalize (GObject *object)
{
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (object);

  g_clear_pointer (&priv->search_text, g_free);
  g_clear_object (&priv->project);

  G_OBJECT_CLASS (_glade_adaptor_chooser_widget_parent_class)->finalize (object);
}

static void
_glade_adaptor_chooser_widget_set_property (GObject      *object, 
                                            guint         prop_id,
                                            const GValue *value,
                                            GParamSpec   *pspec)
{ 
  _GladeAdaptorChooserWidgetPrivate *priv;
  
  g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (object));

  priv = GET_PRIVATE (object);

  switch (prop_id)
    {
      case PROP_SHOW_FLAGS:
        priv->flags = g_value_get_flags (value);
      break;
      case PROP_PROJECT:
        _glade_adaptor_chooser_widget_set_project (GLADE_ADAPTOR_CHOOSER_WIDGET (object),
                                                   g_value_get_object (value));
      break;
      case PROP_SHOW_GROUP_TITLE:
        priv->show_group_title = g_value_get_boolean (value);
      break;
      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
_glade_adaptor_chooser_widget_get_property (GObject    *object,
                                            guint       prop_id,
                                            GValue     *value,
                                            GParamSpec *pspec)
{
  _GladeAdaptorChooserWidgetPrivate *priv;

  g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (object));

  priv = GET_PRIVATE (object);

  switch (prop_id)
    {
      case PROP_SHOW_FLAGS:
        g_value_set_flags (value, priv->flags);
      break;
      case PROP_PROJECT:
        g_value_set_object (value, priv->project);
      break;
      case PROP_SHOW_GROUP_TITLE:
        g_value_set_boolean (value, priv->show_group_title);
      break;
      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static inline gchar *
normalize_name (const gchar *name)
{
  gchar *normalized_name = g_utf8_normalize (name, -1, G_NORMALIZE_DEFAULT);
  gchar *casefold_name = g_utf8_casefold (normalized_name, -1);
  g_free (normalized_name);
  return casefold_name;
}

static inline void
store_append_adaptor (GtkListStore *store, GladeWidgetAdaptor *adaptor)
{
  gchar *normalized_name = normalize_name (glade_widget_adaptor_get_name (adaptor));

  gtk_list_store_insert_with_values (store, NULL, -1,
                                     COLUMN_ADAPTOR, adaptor,
                                     COLUMN_NORMALIZED_NAME, normalized_name,
                                     COLUMN_NORMALIZED_NAME_LEN, strlen (normalized_name),
                                     -1);
  g_free (normalized_name);
}

static void
on_treeview_row_activated (GtkTreeView                *tree_view,
                           GtkTreePath                *path,
                           GtkTreeViewColumn          *column,
                           _GladeAdaptorChooserWidget *chooser)
{
  GtkTreeModel *model = gtk_tree_view_get_model (tree_view); 
  GtkTreeIter iter;

  if (gtk_tree_model_get_iter (model, &iter, path))
    {
      GladeWidgetAdaptor *adaptor;

      gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);

      if (!adaptor)
        return;

      /* Emit selected signal */
      g_signal_emit (chooser, adaptor_chooser_signals[ADAPTOR_SELECTED], 0, adaptor);

      g_object_unref (adaptor);
    }
}

static void
on_searchentry_search_changed (GtkEntry                   *entry,
                               _GladeAdaptorChooserWidget *chooser)
{
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
  const gchar *text = gtk_entry_get_text (entry);

  g_clear_pointer (&priv->search_text, g_free);

  if (g_utf8_strlen (text, -1))
    priv->search_text = normalize_name (text);

  gtk_tree_model_filter_refilter (priv->treemodelfilter);
}

static void
on_searchentry_activate (GtkEntry *entry, _GladeAdaptorChooserWidget *chooser)
{
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
  const gchar *text = gtk_entry_get_text (entry);
  GladeWidgetAdaptor *adaptor;

  /* try to find an adaptor by name */
  if (!(adaptor = glade_widget_adaptor_get_by_name (text)))
    {
      GtkTreeModel *model = GTK_TREE_MODEL (priv->treemodelfilter);
      gchar *normalized_name = normalize_name (text);
      GtkTreeIter iter;
      gboolean valid;
      gint count = 0;

      valid = gtk_tree_model_get_iter_first (model, &iter);

      /* we could not find it check if we can find it by normalized name */
      while (valid)
        {
          gchar *name;

          gtk_tree_model_get (model, &iter, COLUMN_NORMALIZED_NAME, &name, -1);

          if (g_strcmp0 (name, normalized_name) == 0)
            {
              gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
              g_free (name);
              break;
            }

          valid = gtk_tree_model_iter_next (model, &iter);
          g_free (name);
          count++;
        }

      /* if not, and there is only one row, then we select that one */
      if (!adaptor && count == 1 && gtk_tree_model_get_iter_first (model, &iter))
        gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);

      g_free (normalized_name);
    }

  if (adaptor)
    g_signal_emit (chooser, adaptor_chooser_signals[ADAPTOR_SELECTED], 0, adaptor);
}

static gboolean
chooser_match_func (_GladeAdaptorChooserWidget *chooser,
                    GtkTreeModel               *model,
                    const gchar                *key,
                    GtkTreeIter                *iter)
{
  gboolean visible;
  gint name_len;
  gchar *name;

  if (!key || *key == '\0')
    return TRUE;

  gtk_tree_model_get (model, iter,
                      COLUMN_NORMALIZED_NAME, &name,
                      COLUMN_NORMALIZED_NAME_LEN, &name_len,
                      -1);
  if (!name)
    return FALSE;

  visible = (g_strstr_len (name, name_len, key) != NULL);
  g_free (name);

  return visible;
}

static gboolean
treemodelfilter_visible_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
{
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (data);
  GladeWidgetAdaptor *adaptor = NULL;
  gboolean visible = TRUE;

  gtk_tree_model_get (model, iter, COLUMN_ADAPTOR, &adaptor, -1);

  if (!adaptor)
    return priv->show_group_title && !priv->search_text;

  /* Skip classes not available in project target version */
  if (priv->project)
    {
      const gchar *catalog = NULL;
      gint major, minor;

      catalog = glade_widget_adaptor_get_catalog (adaptor);
      glade_project_get_target_version (priv->project, catalog, &major, &minor);

      visible = GWA_VERSION_CHECK (adaptor, major, minor);
    }

  if (visible && priv->flags)
    {
      GType type = glade_widget_adaptor_get_object_type (adaptor);
      _GladeAdaptorChooserWidgetFlags flags = priv->flags;

       /* Skip adaptors according to flags */
       if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED && GWA_DEPRECATED (adaptor))
         visible = FALSE;
       else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL && GWA_IS_TOPLEVEL (adaptor))
         visible = FALSE;
       else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET && !g_type_is_a (type, GTK_TYPE_WIDGET))
         visible = FALSE;
       else if (flags & GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL && !GWA_IS_TOPLEVEL (adaptor))
         visible = FALSE;
    }

  if (visible && priv->search_text)
    visible = chooser_match_func (data, model, priv->search_text, iter);

  g_clear_object (&adaptor);

  return visible;
}

static gboolean
entrycompletion_match_func (GtkEntryCompletion *entry, const gchar *key, GtkTreeIter *iter, gpointer data)
{
  return chooser_match_func (data, gtk_entry_completion_get_model (entry), key, iter);
}

static void
adaptor_icon_cell_data_func (GtkTreeViewColumn *tree_column,
                             GtkCellRenderer   *cell,
                             GtkTreeModel      *tree_model,
                             GtkTreeIter       *iter,
                             gpointer           data)
{
  GladeWidgetAdaptor *adaptor;
  gtk_tree_model_get (tree_model, iter, COLUMN_ADAPTOR, &adaptor, -1);

  if (adaptor)
    g_object_set (cell, "sensitive", TRUE, "icon-name", glade_widget_adaptor_get_icon_name (adaptor), NULL);
  else
    g_object_set (cell, "sensitive", FALSE, "icon-name", "go-down-symbolic", NULL);

  g_clear_object (&adaptor);
}

static void
adaptor_text_cell_data_func (GtkTreeViewColumn *tree_column,
                             GtkCellRenderer   *cell,
                             GtkTreeModel      *tree_model,
                             GtkTreeIter       *iter,
                             gpointer           data)
{
  GladeWidgetAdaptor *adaptor;
  gchar *group;

  gtk_tree_model_get (tree_model, iter,
                      COLUMN_ADAPTOR, &adaptor,
                      COLUMN_GROUP, &group,
                      -1);
  if (adaptor)
    g_object_set (cell,
                  "sensitive", TRUE,
                  "text", glade_widget_adaptor_get_name (adaptor),
                  "style", PANGO_STYLE_NORMAL,
                  NULL);
  else
    g_object_set (cell,
                  "sensitive", FALSE,
                  "text", group,
                  "style", PANGO_STYLE_ITALIC,
                  NULL);

  g_clear_object (&adaptor);
  g_free (group);
}

static void
glade_adaptor_chooser_widget_drag_begin (GtkWidget      *widget,
                                         GdkDragContext *context,
                                         gpointer        data)
{
  GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
  GtkTreeModel *model;
  GtkTreeIter iter;

  if (gtk_tree_selection_get_selected (selection, &model, &iter))
    {
      GladeWidgetAdaptor *adaptor;
      gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
      _glade_dnd_set_icon_widget (context,
                                  glade_widget_adaptor_get_icon_name (adaptor),
                                  glade_widget_adaptor_get_name (adaptor));
    }
}

static void
glade_adaptor_chooser_widget_drag_data_get (GtkWidget          *widget,
                                            GdkDragContext     *context,
                                            GtkSelectionData   *data,
                                            guint               info,
                                            guint               time,
                                            gpointer            userdata)
{
  GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
  GtkTreeModel *model;
  GtkTreeIter iter;

  if (gtk_tree_selection_get_selected (selection, &model, &iter))
    {
      GladeWidgetAdaptor *adaptor;
      gtk_tree_model_get (model, &iter, COLUMN_ADAPTOR, &adaptor, -1);
      _glade_dnd_set_data (data, G_OBJECT (adaptor));
    }
}

static void
_glade_adaptor_chooser_widget_constructed (GObject *object)
{
  _GladeAdaptorChooserWidget *chooser = GLADE_ADAPTOR_CHOOSER_WIDGET (object);
  _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);

  /* Set cell data function: this save us from alocating name and icon name for each adaptor. */
  gtk_tree_view_column_set_cell_data_func (priv->column_icon,
                                           priv->icon_cell,
                                           adaptor_icon_cell_data_func,
                                           NULL, NULL);
  gtk_tree_view_column_set_cell_data_func (priv->column_adaptor,
                                           priv->adaptor_cell,
                                           adaptor_text_cell_data_func,
                                           NULL, NULL);
  /* Set tree model filter function */
  gtk_tree_model_filter_set_visible_func (priv->treemodelfilter,
                                          treemodelfilter_visible_func,
                                          chooser, NULL);
  /* Set completion match function */
  gtk_entry_completion_set_match_func (priv->entrycompletion,
                                       entrycompletion_match_func,
                                       chooser, NULL);
  /* Enable Drag & Drop */
  gtk_tree_view_enable_model_drag_source (priv->treeview, GDK_BUTTON1_MASK,
                                          _glade_dnd_get_target (), 1, 0);
  g_signal_connect_after (priv->treeview, "drag-begin",
                          G_CALLBACK (glade_adaptor_chooser_widget_drag_begin),
                          NULL);
  g_signal_connect (priv->treeview, "drag-data-get",
                    G_CALLBACK (glade_adaptor_chooser_widget_drag_data_get),
                    NULL);
}

static void
_glade_adaptor_chooser_widget_map (GtkWidget *widget)
{
  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);

  if (toplevel)
    {
      _GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (widget);
      gint height = gtk_widget_get_allocated_height (toplevel) - 100;

      if (height > 512)
        height = height * 0.75;

      gtk_scrolled_window_set_max_content_height (priv->scrolledwindow, height);
    }

  GTK_WIDGET_CLASS (_glade_adaptor_chooser_widget_parent_class)->map (widget);
}

static GType
_glade_adaptor_chooser_widget_flags_get_type (void)
{
    static GType etype = 0;
    if (G_UNLIKELY(etype == 0)) {
        static const GFlagsValue values[] = {
            { GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET, "GLADE_ADAPTOR_CHOOSER_WIDGET_WIDGET", "widget" },
            { GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL, "GLADE_ADAPTOR_CHOOSER_WIDGET_TOPLEVEL", "toplevel" },
            { GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL, "GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_TOPLEVEL", "skip-toplevel" },
            { GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED, "GLADE_ADAPTOR_CHOOSER_WIDGET_SKIP_DEPRECATED", "skip-deprecated" },
            { 0, NULL, NULL }
        };
        etype = g_flags_register_static (g_intern_static_string ("_GladeAdaptorChooserWidgetFlag"), values);
    }
    return etype;
}

static void
_glade_adaptor_chooser_widget_class_init (_GladeAdaptorChooserWidgetClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

  object_class->finalize = _glade_adaptor_chooser_widget_finalize;
  object_class->set_property = _glade_adaptor_chooser_widget_set_property;
  object_class->get_property = _glade_adaptor_chooser_widget_get_property;
  object_class->constructed = _glade_adaptor_chooser_widget_constructed;

  widget_class->map = _glade_adaptor_chooser_widget_map;

  g_object_class_install_property (object_class,
                                   PROP_SHOW_FLAGS,
                                   g_param_spec_flags ("show-flags",
                                                       "Show flags",
                                                       "Widget adaptors show flags",
                                                       _glade_adaptor_chooser_widget_flags_get_type (),
                                                       0,
                                                       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  g_object_class_install_property (object_class,
                                   PROP_SHOW_GROUP_TITLE,
                                   g_param_spec_boolean ("show-group-title",
                                                         "Show group title",
                                                         "Whether to show the group title",
                                                         FALSE,
                                                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
  g_object_class_install_property (object_class,
                                   PROP_PROJECT,
                                   g_param_spec_object ("project",
                                                        "Glade Project",
                                                        "If set, use project target version to skip unsupported classes",
                                                        GLADE_TYPE_PROJECT,
                                                        G_PARAM_READWRITE));

  adaptor_chooser_signals[ADAPTOR_SELECTED] =
    g_signal_new ("adaptor-selected", G_OBJECT_CLASS_TYPE (klass), 0, 0,
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 1,
                  GLADE_TYPE_WIDGET_ADAPTOR);

  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/gladeui/glade-adaptor-chooser-widget.ui");
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, treeview);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, store);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, treemodelfilter);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, searchentry);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, entrycompletion);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, column_icon);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, icon_cell);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, column_adaptor);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, adaptor_cell);
  gtk_widget_class_bind_template_child_private (widget_class, _GladeAdaptorChooserWidget, scrolledwindow);
  gtk_widget_class_bind_template_callback (widget_class, on_treeview_row_activated);
  gtk_widget_class_bind_template_callback (widget_class, on_searchentry_search_changed);
  gtk_widget_class_bind_template_callback (widget_class, on_searchentry_activate);
}

GtkWidget *
_glade_adaptor_chooser_widget_new (_GladeAdaptorChooserWidgetFlags flags, GladeProject *project)
{
  return GTK_WIDGET (g_object_new (GLADE_TYPE_ADAPTOR_CHOOSER_WIDGET,
                                   "show-flags", flags,
                                   "project", project,
                                   NULL));
}

void
_glade_adaptor_chooser_widget_set_project (_GladeAdaptorChooserWidget *chooser,
                                           GladeProject               *project)
{
  _GladeAdaptorChooserWidgetPrivate *priv;

  g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));
  priv = GET_PRIVATE (chooser);

  g_clear_object (&priv->project);

  if (project)
    priv->project = g_object_ref (project);

  gtk_tree_model_filter_refilter (priv->treemodelfilter);
}

void
_glade_adaptor_chooser_widget_populate (_GladeAdaptorChooserWidget *chooser)
{
  GList *l;

  for (l = glade_app_get_catalogs (); l; l = g_list_next (l))
    _glade_adaptor_chooser_widget_add_catalog (chooser, l->data);
}

void
_glade_adaptor_chooser_widget_add_catalog (_GladeAdaptorChooserWidget *chooser,
                                           GladeCatalog               *catalog)
{
  GList *groups;

  g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));

  for (groups = glade_catalog_get_widget_groups (catalog); groups;
       groups = g_list_next (groups))
    _glade_adaptor_chooser_widget_add_group (chooser, groups->data);
}

void
_glade_adaptor_chooser_widget_add_group (_GladeAdaptorChooserWidget *chooser,
                                         GladeWidgetGroup           *group)
{
  _GladeAdaptorChooserWidgetPrivate *priv;
  const GList *adaptors;

  g_return_if_fail (GLADE_IS_ADAPTOR_CHOOSER_WIDGET (chooser));
  priv = GET_PRIVATE (chooser);

  if (priv->show_group_title)
    gtk_list_store_insert_with_values (priv->store, NULL, -1,
                                       COLUMN_GROUP, glade_widget_group_get_title (group),
                                       -1);

  for (adaptors = glade_widget_group_get_adaptors (group); adaptors;
       adaptors = g_list_next (adaptors))
    store_append_adaptor (priv->store, adaptors->data);
}