/*
 * Copyright © 2019 Matthias Clasen
 *
 * 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/>.
 *
 * Authors: Matthias Clasen <mclasen@redhat.com>
 */

#include "config.h"

#include "gtkstringsorter.h"

#include "gtkintl.h"
#include "gtksorterprivate.h"
#include "gtktypebuiltins.h"

/**
 * SECTION:gtkstringsorter
 * @Title: GtkStringSorter
 * @Short_description: Sort by comparing strings
 * @See_also: #GtkExpression
 *
 * GtkStringSorter is a #GtkSorter that compares strings. It does the
 * comparison in a linguistically correct way using the current locale by
 * normalizing Unicode strings and possibly case-folding them before
 * performing the comparison.
 *
 * To obtain the strings to compare, this sorter evaluates a #GtkExpression.
 */

struct _GtkStringSorter
{
  GtkSorter parent_instance;

  gboolean ignore_case;

  GtkExpression *expression;
};

enum {
  PROP_0,
  PROP_EXPRESSION,
  PROP_IGNORE_CASE,
  NUM_PROPERTIES
};

G_DEFINE_TYPE (GtkStringSorter, gtk_string_sorter, GTK_TYPE_SORTER)

static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };

static char *
gtk_string_sorter_get_key (GtkExpression *expression,
                           gboolean       ignore_case,
                           gpointer       item1)
{
  GValue value = G_VALUE_INIT;
  char *s;

  if (expression == NULL)
    return NULL;

  if (!gtk_expression_evaluate (expression, item1, &value))
    return NULL;

  /* If strings are NULL, order them before "". */
  if (ignore_case)
    {
      char *t;

      t = g_utf8_casefold (g_value_get_string (&value), -1);
      s = g_utf8_collate_key (t, -1);
      g_free (t);
    }
  else
    {
      s = g_utf8_collate_key (g_value_get_string (&value), -1);
    }

  g_value_unset (&value);

  return s;
}

static GtkOrdering
gtk_string_sorter_compare (GtkSorter *sorter,
                           gpointer   item1,
                           gpointer   item2)
{
  GtkStringSorter *self = GTK_STRING_SORTER (sorter);
  char *s1, *s2;
  GtkOrdering result;

  if (self->expression == NULL)
    return GTK_ORDERING_EQUAL;

  s1 = gtk_string_sorter_get_key (self->expression, self->ignore_case, item1);
  s2 = gtk_string_sorter_get_key (self->expression, self->ignore_case, item2);

  result = gtk_ordering_from_cmpfunc (g_strcmp0 (s1, s2));

  g_free (s1);
  g_free (s2);

  return result;
}

static GtkSorterOrder
gtk_string_sorter_get_order (GtkSorter *sorter)
{
  GtkStringSorter *self = GTK_STRING_SORTER (sorter);

  if (self->expression == NULL)
    return GTK_SORTER_ORDER_NONE;

  return GTK_SORTER_ORDER_PARTIAL;
}

typedef struct _GtkStringSortKeys GtkStringSortKeys;
struct _GtkStringSortKeys
{
  GtkSortKeys keys;

  GtkExpression *expression;
  gboolean ignore_case;
};

static void
gtk_string_sort_keys_free (GtkSortKeys *keys)
{
  GtkStringSortKeys *self = (GtkStringSortKeys *) keys;

  gtk_expression_unref (self->expression);
  g_slice_free (GtkStringSortKeys, self);
}

static int
gtk_string_sort_keys_compare (gconstpointer a,
                              gconstpointer b,
                              gpointer      unused)
{
  const char *sa = *(const char **) a;
  const char *sb = *(const char **) b;

  if (sa == NULL)
    return sb == NULL ? GTK_ORDERING_EQUAL : GTK_ORDERING_LARGER;
  else if (sb == NULL)
    return GTK_ORDERING_SMALLER;

  return gtk_ordering_from_cmpfunc (strcmp (sa, sb));
}

static gboolean
gtk_string_sort_keys_is_compatible (GtkSortKeys *keys,
                                    GtkSortKeys *other)
{
  return FALSE;
}

static void
gtk_string_sort_keys_init_key (GtkSortKeys *keys,
                               gpointer     item,
                               gpointer     key_memory)
{
  GtkStringSortKeys *self = (GtkStringSortKeys *) keys;
  char **key = (char **) key_memory;

  *key = gtk_string_sorter_get_key (self->expression, self->ignore_case, item);
}

static void
gtk_string_sort_keys_clear_key (GtkSortKeys *keys,
                                gpointer     key_memory)
{
  char **key = (char **) key_memory;

  g_free (*key);
}

static const GtkSortKeysClass GTK_STRING_SORT_KEYS_CLASS =
{
  gtk_string_sort_keys_free,
  gtk_string_sort_keys_compare,
  gtk_string_sort_keys_is_compatible,
  gtk_string_sort_keys_init_key,
  gtk_string_sort_keys_clear_key,
};

static GtkSortKeys *
gtk_string_sort_keys_new (GtkStringSorter *self)
{
  GtkStringSortKeys *result;

  if (self->expression == NULL)
    return gtk_sort_keys_new_equal ();

  result = gtk_sort_keys_new (GtkStringSortKeys,
                              &GTK_STRING_SORT_KEYS_CLASS,
                              sizeof (char *),
                              sizeof (char *));

  result->expression = gtk_expression_ref (self->expression);
  result->ignore_case = self->ignore_case;

  return (GtkSortKeys *) result;
}

static void
gtk_string_sorter_set_property (GObject      *object,
                                guint         prop_id,
                                const GValue *value,
                                GParamSpec   *pspec)
{
  GtkStringSorter *self = GTK_STRING_SORTER (object);

  switch (prop_id)
    {
    case PROP_EXPRESSION:
      gtk_string_sorter_set_expression (self, gtk_value_get_expression (value));
      break;

    case PROP_IGNORE_CASE:
      gtk_string_sorter_set_ignore_case (self, g_value_get_boolean (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void 
gtk_string_sorter_get_property (GObject     *object,
                                guint        prop_id,
                                GValue      *value,
                                GParamSpec  *pspec)
{
  GtkStringSorter *self = GTK_STRING_SORTER (object);

  switch (prop_id)
    {
    case PROP_EXPRESSION:
      gtk_value_set_expression (value, self->expression);
      break;

    case PROP_IGNORE_CASE:
      g_value_set_boolean (value, self->ignore_case);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gtk_string_sorter_dispose (GObject *object)
{
  GtkStringSorter *self = GTK_STRING_SORTER (object);

  g_clear_pointer (&self->expression, gtk_expression_unref);

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

static void
gtk_string_sorter_class_init (GtkStringSorterClass *class)
{
  GtkSorterClass *sorter_class = GTK_SORTER_CLASS (class);
  GObjectClass *object_class = G_OBJECT_CLASS (class);

  sorter_class->compare = gtk_string_sorter_compare;
  sorter_class->get_order = gtk_string_sorter_get_order;

  object_class->get_property = gtk_string_sorter_get_property;
  object_class->set_property = gtk_string_sorter_set_property;
  object_class->dispose = gtk_string_sorter_dispose;

  /**
   * GtkStringSorter:expression: (type GtkExpression)
   *
   * The expression to evaluate on item to get a string to compare with
   */
  properties[PROP_EXPRESSION] =
    gtk_param_spec_expression ("expression",
                               P_("Expression"),
                               P_("Expression to compare with"),
                               G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);

  /**
   * GtkStringSorter:ignore-case:
   *
   * If matching is case sensitive
   */
  properties[PROP_IGNORE_CASE] =
      g_param_spec_boolean ("ignore-case",
                            P_("Ignore case"),
                            P_("If matching is case sensitive"),
                            TRUE,
                            G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);

  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);

}

static void
gtk_string_sorter_init (GtkStringSorter *self)
{
  self->ignore_case = TRUE;

  gtk_sorter_changed_with_keys (GTK_SORTER (self),
                                GTK_SORTER_CHANGE_DIFFERENT,
                                gtk_string_sort_keys_new (self));
}

/**
 * gtk_string_sorter_new:
 * @expression: (transfer full) (nullable): The expression to evaluate
 *
 * Creates a new string sorter that compares items using the given
 * @expression.
 *
 * Unless an expression is set on it, this sorter will always
 * compare items as invalid.
 *
 * Returns: a new #GtkSorter
 */
GtkSorter *
gtk_string_sorter_new (GtkExpression *expression)
{
  GtkSorter *result;

  result = g_object_new (GTK_TYPE_STRING_SORTER,
                         "expression", expression,
                         NULL);

  g_clear_pointer (&expression, gtk_expression_unref);

  return result;
}

/**
 * gtk_string_sorter_get_expression:
 * @self: a #GtkStringSorter
 *
 * Gets the expression that is evaluated to obtain strings from items.
 *
 * Returns: (transfer none) (nullable): a #GtkExpression, or %NULL
 */
GtkExpression *
gtk_string_sorter_get_expression (GtkStringSorter *self)
{
  g_return_val_if_fail (GTK_IS_STRING_SORTER (self), NULL);

  return self->expression;
}

/**
 * gtk_string_sorter_set_expression:
 * @self: a #GtkStringSorter
 * @expression: (nullable) (transfer none): a #GtkExpression, or %NULL
 *
 * Sets the expression that is evaluated to obtain strings from items.
 *
 * The expression must have the type G_TYPE_STRING.
 */
void
gtk_string_sorter_set_expression (GtkStringSorter *self,
                                  GtkExpression   *expression)
{
  g_return_if_fail (GTK_IS_STRING_SORTER (self));
  g_return_if_fail (expression == NULL || gtk_expression_get_value_type (expression) == G_TYPE_STRING);

  if (self->expression == expression)
    return;

  g_clear_pointer (&self->expression, gtk_expression_unref);
  if (expression)
    self->expression = gtk_expression_ref (expression);

  gtk_sorter_changed_with_keys (GTK_SORTER (self),
                                GTK_SORTER_CHANGE_DIFFERENT,
                                gtk_string_sort_keys_new (self));

  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EXPRESSION]);
}

/**
 * gtk_string_sorter_get_ignore_case:
 * @self: a #GtkStringSorter
 *
 * Gets whether the sorter ignores case differences.
 *
 * Returns: %TRUE if @self is ignoring case differences
 */
gboolean
gtk_string_sorter_get_ignore_case (GtkStringSorter *self)
{
  g_return_val_if_fail (GTK_IS_STRING_SORTER (self), TRUE);

  return self->ignore_case;
}

/**
 * gtk_string_sorter_set_ignore_case:
 * @self: a #GtkStringSorter
 * @ignore_case: %TRUE to ignore case differences
 *
 * Sets whether the sorter will ignore case differences.
 */
void
gtk_string_sorter_set_ignore_case (GtkStringSorter *self,
                                   gboolean         ignore_case)
{
  g_return_if_fail (GTK_IS_STRING_SORTER (self));

  if (self->ignore_case == ignore_case)
    return;

  self->ignore_case = ignore_case;

  gtk_sorter_changed_with_keys (GTK_SORTER (self),
                                ignore_case ? GTK_SORTER_CHANGE_LESS_STRICT : GTK_SORTER_CHANGE_MORE_STRICT,
                                gtk_string_sort_keys_new (self));

  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_IGNORE_CASE]);
}