/*

 * Copyright © 2010 Codethink Limited

 *

 * 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: Ryan Lortie <desrt@desrt.ca>

 */

/* Prologue {{{1 */

#include "config.h"

#include <gstdio.h>

#include <gi18n.h>

#include <string.h>

#include <stdio.h>

#include <locale.h>

#include "gvdb/gvdb-builder.h"

#include "strinfo.c"

#ifdef G_OS_WIN32

#include "glib/glib-private.h"

#endif

static void

strip_string (GString *string)

{

  gint i;

  for (i = 0; g_ascii_isspace (string->str[i]); i++);

  g_string_erase (string, 0, i);

  if (string->len > 0)

    {

      /* len > 0, so there must be at least one non-whitespace character */

      for (i = string->len - 1; g_ascii_isspace (string->str[i]); i--);

      g_string_truncate (string, i + 1);

    }

}

/* Handling of <enum> {{{1 */

typedef struct

{

  GString *strinfo;

  gboolean is_flags;

} EnumState;

static void

enum_state_free (gpointer data)

{

  EnumState *state = data;

  g_string_free (state->strinfo, TRUE);

  g_slice_free (EnumState, state);

}

static EnumState *

enum_state_new (gboolean is_flags)

{

  EnumState *state;

  state = g_slice_new (EnumState);

  state->strinfo = g_string_new (NULL);

  state->is_flags = is_flags;

  return state;

}

static void

enum_state_add_value (EnumState    *state,

                      const gchar  *nick,

                      const gchar  *valuestr,

                      GError      **error)

{

  gint64 value;

  gchar *end;

  if (nick[0] == '\0' || nick[1] == '\0')

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("nick must be a minimum of 2 characters"));

      return;

    }

  value = g_ascii_strtoll (valuestr, &end, 0);

  if (*end || (state->is_flags ?

                (value > G_MAXUINT32 || value < 0) :

                (value > G_MAXINT32 || value < G_MININT32)))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("Invalid numeric value"));

      return;

    }

  if (strinfo_builder_contains (state->strinfo, nick))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<value nick='%s'/> already specified"), nick);

      return;

    }

  if (strinfo_builder_contains_value (state->strinfo, value))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("value='%s' already specified"), valuestr);

      return;

    }

  /* Silently drop the null case if it is mentioned.

   * It is properly denoted with an empty array.

   */

  if (state->is_flags && value == 0)

    return;

  if (state->is_flags && (value & (value - 1)))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("flags values must have at most 1 bit set"));

      return;

    }

  /* Since we reject exact duplicates of value='' and we only allow one

   * bit to be set, it's not possible to have overlaps.

   *

   * If we loosen the one-bit-set restriction we need an overlap check.

   */

  strinfo_builder_append_item (state->strinfo, nick, value);

}

static void

enum_state_end (EnumState **state_ptr,

                GError    **error)

{

  EnumState *state;

  state = *state_ptr;

  *state_ptr = NULL;

  if (state->strinfo->len == 0)

    g_set_error (error,

                 G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                 _("<%s> must contain at least one <value>"),

                 state->is_flags ? "flags" : "enum");

}

/* Handling of <key> {{{1 */

typedef struct

{

  /* for <child>, @child_schema will be set.

   * for <key>, everything else will be set.

   */

  gchar        *child_schema;

  GVariantType *type;

  gboolean      have_gettext_domain;

  gchar         l10n;

  gchar        *l10n_context;

  GString      *unparsed_default_value;

  GVariant     *default_value;

  GString      *strinfo;

  gboolean      is_enum;

  gboolean      is_flags;

  GVariant     *minimum;

  GVariant     *maximum;

  gboolean      has_choices;

  gboolean      has_aliases;

  gboolean      is_override;

  gboolean      checked;

  GVariant     *serialised;

  gboolean      summary_seen;

  gboolean      description_seen;

} KeyState;

static KeyState *

key_state_new (const gchar *type_string,

               const gchar *gettext_domain,

               gboolean     is_enum,

               gboolean     is_flags,

               GString     *strinfo)

{

  KeyState *state;

  state = g_slice_new0 (KeyState);

  state->type = g_variant_type_new (type_string);

  state->have_gettext_domain = gettext_domain != NULL;

  state->is_enum = is_enum;

  state->is_flags = is_flags;

  state->summary_seen = FALSE;

  state->description_seen = FALSE;

  if (strinfo)

    state->strinfo = g_string_new_len (strinfo->str, strinfo->len);

  else

    state->strinfo = g_string_new (NULL);

  return state;

}

static KeyState *

key_state_override (KeyState    *state,

                    const gchar *gettext_domain)

{

  KeyState *copy;

  copy = g_slice_new0 (KeyState);

  copy->type = g_variant_type_copy (state->type);

  copy->have_gettext_domain = gettext_domain != NULL;

  copy->strinfo = g_string_new_len (state->strinfo->str,

                                    state->strinfo->len);

  copy->is_enum = state->is_enum;

  copy->is_flags = state->is_flags;

  copy->is_override = TRUE;

  if (state->minimum)

    {

      copy->minimum = g_variant_ref (state->minimum);

      copy->maximum = g_variant_ref (state->maximum);

    }

  return copy;

}

static KeyState *

key_state_new_child (const gchar *child_schema)

{

  KeyState *state;

  state = g_slice_new0 (KeyState);

  state->child_schema = g_strdup (child_schema);

  return state;

}

static gboolean

is_valid_choices (GVariant *variant,

                  GString  *strinfo)

{

  switch (g_variant_classify (variant))

    {

      case G_VARIANT_CLASS_MAYBE:

      case G_VARIANT_CLASS_ARRAY:

        {

          gboolean valid = TRUE;

          GVariantIter iter;

          g_variant_iter_init (&iter, variant);

          while (valid && (variant = g_variant_iter_next_value (&iter)))

            {

              valid = is_valid_choices (variant, strinfo);

              g_variant_unref (variant);

            }

          return valid;

        }

      case G_VARIANT_CLASS_STRING:

        return strinfo_is_string_valid ((const guint32 *) strinfo->str,

                                        strinfo->len / 4,

                                        g_variant_get_string (variant, NULL));

      default:

        g_assert_not_reached ();

    }

}

/* Gets called at </default> </choices> or <range/> to check for

 * validity of the default value so that any inconsistency is

 * reported as soon as it is encountered.

 */

static void

key_state_check_range (KeyState  *state,

                       GError   **error)

{

  if (state->default_value)

    {

      const gchar *tag;

      tag = state->is_override ? "override" : "default";

      if (state->minimum)

        {

          if (g_variant_compare (state->default_value, state->minimum) < 0 ||

              g_variant_compare (state->default_value, state->maximum) > 0)

            {

              g_set_error (error, G_MARKUP_ERROR,

                           G_MARKUP_ERROR_INVALID_CONTENT,

                           _("<%s> is not contained in "

                           "the specified range"), tag);

            }

        }

      else if (state->strinfo->len)

        {

          if (!is_valid_choices (state->default_value, state->strinfo))

            {

              if (state->is_enum)

                g_set_error (error, G_MARKUP_ERROR,

                             G_MARKUP_ERROR_INVALID_CONTENT,

                             _("<%s> is not a valid member of "

                             "the specified enumerated type"), tag);

              else if (state->is_flags)

                g_set_error (error, G_MARKUP_ERROR,

                             G_MARKUP_ERROR_INVALID_CONTENT,

                             _("<%s> contains string not in the "

                             "specified flags type"), tag);

              else

                g_set_error (error, G_MARKUP_ERROR,

                             G_MARKUP_ERROR_INVALID_CONTENT,

                             _("<%s> contains a string not in "

                             "<choices>"), tag);

            }

        }

    }

}

static void

key_state_set_range (KeyState     *state,

                     const gchar  *min_str,

                     const gchar  *max_str,

                     GError      **error)

{

  const struct {

    const gchar  type;

    const gchar *min;

    const gchar *max;

  } table[] = {

    { 'y',                    "0",                  "255" },

    { 'n',               "-32768",                "32767" },

    { 'q',                    "0",                "65535" },

    { 'i',          "-2147483648",           "2147483647" },

    { 'u',                    "0",           "4294967295" },

    { 'x', "-9223372036854775808",  "9223372036854775807" },

    { 't',                    "0", "18446744073709551615" },

    { 'd',                 "-inf",                  "inf" },

  };

  gboolean type_ok = FALSE;

  gint i;

  if (state->minimum)

    {

      g_set_error_literal (error, G_MARKUP_ERROR,

                           G_MARKUP_ERROR_INVALID_CONTENT,

                           _("<range/> already specified for this key"));

      return;

    }

  for (i = 0; i < G_N_ELEMENTS (table); i++)

    if (*(char *) state->type == table[i].type)

      {

        min_str = min_str ? min_str : table[i].min;

        max_str = max_str ? max_str : table[i].max;

        type_ok = TRUE;

        break;

      }

  if (!type_ok)

    {

      gchar *type = g_variant_type_dup_string (state->type);

      g_set_error (error, G_MARKUP_ERROR,

                  G_MARKUP_ERROR_INVALID_CONTENT,

                  _("<range> not allowed for keys of type “%s”"), type);

      g_free (type);

      return;

    }

  state->minimum = g_variant_parse (state->type, min_str, NULL, NULL, error);

  if (state->minimum == NULL)

    return;

  state->maximum = g_variant_parse (state->type, max_str, NULL, NULL, error);

  if (state->maximum == NULL)

    return;

  if (g_variant_compare (state->minimum, state->maximum) > 0)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<range> specified minimum is greater than maximum"));

      return;

    }

  key_state_check_range (state, error);

}

static GString *

key_state_start_default (KeyState     *state,

                         const gchar  *l10n,

                         const gchar  *context,

                         GError      **error)

{

  if (l10n != NULL)

    {

      if (strcmp (l10n, "messages") == 0)

        state->l10n = 'm';

      else if (strcmp (l10n, "time") == 0)

        state->l10n = 't';

      else

        {

          g_set_error (error, G_MARKUP_ERROR,

                       G_MARKUP_ERROR_INVALID_CONTENT,

                       _("unsupported l10n category: %s"), l10n);

          return NULL;

        }

      if (!state->have_gettext_domain)

        {

          g_set_error_literal (error, G_MARKUP_ERROR,

                               G_MARKUP_ERROR_INVALID_CONTENT,

                               _("l10n requested, but no "

                               "gettext domain given"));

          return NULL;

        }

      state->l10n_context = g_strdup (context);

    }

  else if (context != NULL)

    {

      g_set_error_literal (error, G_MARKUP_ERROR,

                           G_MARKUP_ERROR_INVALID_CONTENT,

                           _("translation context given for "

                           "value without l10n enabled"));

      return NULL;

    }

  return g_string_new (NULL);

}

static void

key_state_end_default (KeyState  *state,

                       GString  **string,

                       GError   **error)

{

  state->unparsed_default_value = *string;

  *string = NULL;

  state->default_value = g_variant_parse (state->type,

                                          state->unparsed_default_value->str,

                                          NULL, NULL, error);

  if (!state->default_value)

    {

      gchar *type = g_variant_type_dup_string (state->type);

      g_prefix_error (error, _("Failed to parse <default> value of type “%s”: "), type);

      g_free (type);

    }

  key_state_check_range (state, error);

}

static void

key_state_start_choices (KeyState  *state,

                         GError   **error)

{

  const GVariantType *type = state->type;

  if (state->is_enum)

    {

      g_set_error_literal (error, G_MARKUP_ERROR,

                           G_MARKUP_ERROR_INVALID_CONTENT,

                           _("<choices> cannot be specified for keys "

                           "tagged as having an enumerated type"));

      return;

    }

  if (state->has_choices)

    {

      g_set_error_literal (error, G_MARKUP_ERROR,

                           G_MARKUP_ERROR_INVALID_CONTENT,

                           _("<choices> already specified for this key"));

      return;

    }

  while (g_variant_type_is_maybe (type) || g_variant_type_is_array (type))

    type = g_variant_type_element (type);

  if (!g_variant_type_equal (type, G_VARIANT_TYPE_STRING))

    {

      gchar *type_string = g_variant_type_dup_string (state->type);

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<choices> not allowed for keys of type “%s”"),

                   type_string);

      g_free (type_string);

      return;

    }

}

static void

key_state_add_choice (KeyState     *state,

                      const gchar  *choice,

                      GError      **error)

{

  if (strinfo_builder_contains (state->strinfo, choice))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<choice value='%s'/> already given"), choice);

      return;

    }

  strinfo_builder_append_item (state->strinfo, choice, 0);

  state->has_choices = TRUE;

}

static void

key_state_end_choices (KeyState  *state,

                       GError   **error)

{

  if (!state->has_choices)

    {

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<choices> must contain at least one <choice>"));

      return;

    }

  key_state_check_range (state, error);

}

static void

key_state_start_aliases (KeyState  *state,

                         GError   **error)

{

  if (state->has_aliases)

    g_set_error_literal (error, G_MARKUP_ERROR,

                         G_MARKUP_ERROR_INVALID_CONTENT,

                         _("<aliases> already specified for this key"));

  else if (!state->is_flags && !state->is_enum && !state->has_choices)

    g_set_error_literal (error, G_MARKUP_ERROR,

                         G_MARKUP_ERROR_INVALID_CONTENT,

                         _("<aliases> can only be specified for keys with "

                         "enumerated or flags types or after <choices>"));

}

static void

key_state_add_alias (KeyState     *state,

                     const gchar  *alias,

                     const gchar  *target,

                     GError      **error)

{

  if (strinfo_builder_contains (state->strinfo, alias))

    {

      if (strinfo_is_string_valid ((guint32 *) state->strinfo->str,

                                   state->strinfo->len / 4,

                                   alias))

        {

          if (state->is_enum)

            g_set_error (error, G_MARKUP_ERROR,

                         G_MARKUP_ERROR_INVALID_CONTENT,

                         _("<alias value='%s'/> given when “%s” is already "

                         "a member of the enumerated type"), alias, alias);

          else

            g_set_error (error, G_MARKUP_ERROR,

                         G_MARKUP_ERROR_INVALID_CONTENT,

                         _("<alias value='%s'/> given when "

                         "<choice value='%s'/> was already given"),

                         alias, alias);

        }

      else

        g_set_error (error, G_MARKUP_ERROR,

                     G_MARKUP_ERROR_INVALID_CONTENT,

                     _("<alias value='%s'/> already specified"), alias);

      return;

    }

  if (!strinfo_builder_append_alias (state->strinfo, alias, target))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_INVALID_CONTENT,

                   state->is_enum ?

                     _("alias target “%s” is not in enumerated type") :

                     _("alias target “%s” is not in <choices>"),

                   target);

      return;

    }

  state->has_aliases = TRUE;

}

static void

key_state_end_aliases (KeyState  *state,

                       GError   **error)

{

  if (!state->has_aliases)

    {

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   _("<aliases> must contain at least one <alias>"));

      return;

    }

}

static gboolean

key_state_check (KeyState  *state,

                 GError   **error)

{

  if (state->checked)

    return TRUE;

  return state->checked = TRUE;

}

static GVariant *

key_state_serialise (KeyState *state)

{

  if (state->serialised == NULL)

    {

      if (state->child_schema)

        {

          state->serialised = g_variant_new_string (state->child_schema);

        }

      else

        {

          GVariantBuilder builder;

          g_assert (key_state_check (state, NULL));

          g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);

          /* default value */

          g_variant_builder_add_value (&builder, state->default_value);

          /* translation */

          if (state->l10n)

            {

              /* We are going to store the untranslated default for

               * runtime translation according to the current locale.

               * We need to strip leading and trailing whitespace from

               * the string so that it's exactly the same as the one

               * that ended up in the .po file for translation.

               *

               * We want to do this so that

               *

               *   <default l10n='messages'>

               *     ['a', 'b', 'c']

               *   </default>

               *

               * ends up in the .po file like "['a', 'b', 'c']",

               * omitting the extra whitespace at the start and end.

               */

              strip_string (state->unparsed_default_value);

              if (state->l10n_context)

                {

                  gint len;

                  /* Contextified messages are supported by prepending

                   * the context, followed by '\004' to the start of the

                   * message string.  We do that here to save GSettings

                   * the work later on.

                   */

                  len = strlen (state->l10n_context);

                  state->l10n_context[len] = '\004';

                  g_string_prepend_len (state->unparsed_default_value,

                                        state->l10n_context, len + 1);

                  g_free (state->l10n_context);

                  state->l10n_context = NULL;

                }

              g_variant_builder_add (&builder, "(y(y&s))", 'l', state->l10n,

                                     state->unparsed_default_value->str);

              g_string_free (state->unparsed_default_value, TRUE);

              state->unparsed_default_value = NULL;

            }

          /* choice, aliases, enums */

          if (state->strinfo->len)

            {

              GVariant *array;

              guint32 *words;

              gpointer data;

              gsize size;

              gint i;

              data = state->strinfo->str;

              size = state->strinfo->len;

              words = data;

              for (i = 0; i < size / sizeof (guint32); i++)

                words[i] = GUINT32_TO_LE (words[i]);

              array = g_variant_new_from_data (G_VARIANT_TYPE ("au"),

                                               data, size, TRUE,

                                               g_free, data);

              g_string_free (state->strinfo, FALSE);

              state->strinfo = NULL;

              g_variant_builder_add (&builder, "(y@au)",

                                     state->is_flags ? 'f' :

                                     state->is_enum ? 'e' : 'c',

                                     array);

            }

          /* range */

          if (state->minimum || state->maximum)

            g_variant_builder_add (&builder, "(y(**))", 'r',

                                   state->minimum, state->maximum);

          state->serialised = g_variant_builder_end (&builder);

        }

      g_variant_ref_sink (state->serialised);

    }

  return g_variant_ref (state->serialised);

}

static void

key_state_free (gpointer data)

{

  KeyState *state = data;

  if (state->type)

    g_variant_type_free (state->type);

  g_free (state->l10n_context);

  if (state->unparsed_default_value)

    g_string_free (state->unparsed_default_value, TRUE);

  if (state->default_value)

    g_variant_unref (state->default_value);

  if (state->strinfo)

    g_string_free (state->strinfo, TRUE);

  if (state->minimum)

    g_variant_unref (state->minimum);

  if (state->maximum)

    g_variant_unref (state->maximum);

  if (state->serialised)

    g_variant_unref (state->serialised);

  g_slice_free (KeyState, state);

}

/* Key name validity {{{1 */

static gboolean allow_any_name = FALSE;

static gboolean

is_valid_keyname (const gchar  *key,

                  GError      **error)

{

  gint i;

  if (key[0] == '\0')

    {

      g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                           _("Empty names are not permitted"));

      return FALSE;

    }

  if (allow_any_name)

    return TRUE;

  if (!g_ascii_islower (key[0]))

    {

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   _("Invalid name “%s”: names must begin "

                     "with a lowercase letter"), key);

      return FALSE;

    }

  for (i = 1; key[i]; i++)

    {

      if (key[i] != '-' &&

          !g_ascii_islower (key[i]) &&

          !g_ascii_isdigit (key[i]))

        {

          g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                       _("Invalid name “%s”: invalid character “%c”; "

                         "only lowercase letters, numbers and hyphen (“-”) "

                         "are permitted"), key, key[i]);

          return FALSE;

        }

      if (key[i] == '-' && key[i + 1] == '-')

        {

          g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                       _("Invalid name “%s”: two successive hyphens (“--”) "

                         "are not permitted"), key);

          return FALSE;

        }

    }

  if (key[i - 1] == '-')

    {

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   _("Invalid name “%s”: the last character may not be a "

                     "hyphen (“-”)"), key);

      return FALSE;

    }

  if (i > 1024)

    {

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   _("Invalid name “%s”: maximum length is 1024"), key);

      return FALSE;

    }

  return TRUE;

}

/* Handling of <schema> {{{1 */

typedef struct _SchemaState SchemaState;

struct _SchemaState

{

  SchemaState *extends;

  gchar       *path;

  gchar       *gettext_domain;

  gchar       *extends_name;

  gchar       *list_of;

  GHashTable  *keys;

};

static SchemaState *

schema_state_new (const gchar  *path,

                  const gchar  *gettext_domain,

                  SchemaState  *extends,

                  const gchar  *extends_name,

                  const gchar  *list_of)

{

  SchemaState *state;

  state = g_slice_new (SchemaState);

  state->path = g_strdup (path);

  state->gettext_domain = g_strdup (gettext_domain);

  state->extends = extends;

  state->extends_name = g_strdup (extends_name);

  state->list_of = g_strdup (list_of);

  state->keys = g_hash_table_new_full (g_str_hash, g_str_equal,

                                       g_free, key_state_free);

  return state;

}

static void

schema_state_free (gpointer data)

{

  SchemaState *state = data;