/*
 * Copyright © 2010 Codethink Limited
 * Copyright © 2013 Canonical 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 of the licence, 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, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Author: Ryan Lortie <desrt@desrt.ca>
 */

#define _(x)(x)

#include <gio/gio.h>
#include "gvdb/gvdb-builder.h"
#include "strinfo.c"

/* Forward declarations {{{1 */
typedef struct _FileRef                                     FileRef;
typedef struct _Enum                                        Enum;
typedef struct _Schema                                      Schema;
typedef struct _Override                                    Override;
typedef struct _Key                                         Key;
typedef struct _Dir                                         Dir;

static Schema *         dir_resolve_schema              (Dir            *dir,
                                                         const gchar    *id,
                                                         const gchar    *detail,
                                                         const gchar    *purpose,
                                                         const gchar    *caller,
                                                         GError        **error);
static Enum *           dir_resolve_enum                (Dir            *dir,
                                                         const gchar    *id,
                                                         gboolean        is_flags,
                                                         const gchar    *for_key,
                                                         const gchar    *of_schema,
                                                         GError        **error);
static Enum *           schema_resolve_enum             (Schema         *schema,
                                                         const gchar    *id,
                                                         gboolean        is_flags,
                                                         const gchar    *for_key,
                                                         GError        **error);

static gboolean         dir_add_enum                    (Dir            *dir,
                                                         GMarkupReader  *reader,
                                                         const gchar    *id,
                                                         Enum           *enum_,
                                                         GError        **error);

static gboolean         dir_add_schema                  (Dir            *dir,
                                                         GMarkupReader  *reader,
                                                         const gchar    *id,
                                                         Schema         *schema,
                                                         GError        **error);

static gboolean         schema_add_key                  (Schema         *schema,
                                                         GMarkupReader  *reader,
                                                         const gchar    *name,
                                                         Key            *key,
                                                         GError        **error);

/* <enum> and <flags> {{{1 */

struct _Enum
{
  Dir          *dir;
  gchar        *id;
  gboolean      is_flags;
  GString      *strinfo;
};

static void
enum_free (gpointer data)
{
  Enum *enum_ = data;

  g_string_free (enum_->strinfo, TRUE);
  g_free (enum_->id);

  g_slice_free (Enum, enum_);
}

static gboolean
enum_parse_value (GMarkupReader  *reader,
                  GCancellable   *cancellable,
                  Enum           *enum_,
                  GError        **error)
{
  const gchar *nick, *valuestr;
  gint64 value;
  gchar *end;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRING, "nick", &nick,
                                           G_MARKUP_COLLECT_STRING, "value", &valuestr,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  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 FALSE;
    }

  value = g_ascii_strtoll (valuestr, &end, 0);
  if (*end || enum_->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 FALSE;
    }

  if (strinfo_builder_contains (enum_->strinfo, nick))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<value nick='%s'/> already specified", nick);
      return FALSE;
    }

  if (strinfo_builder_contains_value (enum_->strinfo, value))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "value='%s' already specified", valuestr);
      return FALSE;
    }

  /* Silently drop the null case if it is mentioned.
   * It is properly denoted with an empty array.
   */
  if (enum_->is_flags && value == 0)
    return TRUE;

  if (enum_->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 FALSE;
    }

  /* 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 (enum_->strinfo, nick, value);

  return g_markup_reader_expect_end (reader, NULL, error);
}

static gboolean
enum_parse (GMarkupReader  *reader,
            GCancellable   *cancellable,
            Dir            *dir,
            GError        **error)
{
  Enum *enum_;

  enum_ = g_slice_new0 (Enum);
  enum_->is_flags = g_markup_reader_is_start_element (reader, "flags");
  enum_->strinfo = g_string_new (NULL);

  g_assert (enum_->is_flags || g_markup_reader_is_start_element (reader, "enum"));

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRDUP, "id", &enum_->id,
                                           G_MARKUP_COLLECT_INVALID))
    goto error;

  if (!g_markup_reader_collect_elements (reader, cancellable, enum_, error, "value", enum_parse_value, NULL))
    goto error;

  if (!dir_add_enum (dir, reader, enum_->id, enum_, error))
    goto error;

  return TRUE;

error:
  enum_free (enum_);

  return FALSE;
}

/* <key> {{{1 */

struct _Key
{
  Schema       *schema;
  const gchar  *name;

  gchar        *type_string;
  GVariantType *type;
  gchar        *enum_name;
  Enum         *enum_;
  gchar        *flags_name;
  Enum         *flags;

  gchar         l10n;
  gchar        *l10n_context;
  gchar        *default_text;
  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;
};

static void
key_free (gpointer data)
{
  Key *key = data;

  g_slice_free (Key, key);
}

static gboolean
key_resolve (Key     *key,
             GError **error)
{
  if (key->enum_name)
    {
      key->enum_ = schema_resolve_enum (key->schema, key->enum_name, FALSE, key->name, error);
      if (key->enum_ == NULL)
        return FALSE;
    }

  if (key->flags_name)
    {
      key->flags = schema_resolve_enum (key->schema, key->flags_name, TRUE, key->name, error);
      if (key->flags == NULL)
        return FALSE;
    }

  return TRUE;
}

static gboolean
key_parse_default (GMarkupReader  *reader,
                   GCancellable   *cancellable,
                   Key            *key,
                   GError        **error)
{
  if (key->default_value)
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT, "<default/> must be specified exactly once");
      return FALSE;
    }

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "l10n", &key->l10n,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "context", &key->l10n_context,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  key->default_text = g_markup_reader_collect_text (reader, cancellable, error);

  return key->default_text != NULL;
}

static gboolean
key_parse_range (GMarkupReader  *reader,
                 GCancellable   *cancellable,
                 Key            *key,
                 GError        **error)
{
  const gchar *min_str, *max_str;
  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 (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "min", &min_str,
                                           G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "max", &max_str,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  if (key->minimum)
    {
      g_set_error_literal (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                           "<range/> already specified for this key");
      return FALSE;
    }

  for (i = 0; i < G_N_ELEMENTS (table); i++)
    if (*(char *) key->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)
    {
      g_set_error (error, G_MARKUP_ERROR,
                  G_MARKUP_ERROR_INVALID_CONTENT,
                  "<range> not allowed for keys of type '%s'", key->type_string);
      return FALSE;
    }

  key->minimum = g_variant_parse (key->type, min_str, NULL, NULL, error);
  if (key->minimum == NULL)
    return FALSE;

  key->maximum = g_variant_parse (key->type, max_str, NULL, NULL, error);
  if (key->maximum == NULL)
    return FALSE;

  if (g_variant_compare (key->minimum, key->maximum) > 0)
    {
      g_set_error (error, G_MARKUP_ERROR,
                   G_MARKUP_ERROR_INVALID_CONTENT,
                   "<range> specified minimum is greater than maxmimum");
      return FALSE;
    }

  return g_markup_reader_expect_end (reader, cancellable, error);
}

static gboolean
key_parse_choice (GMarkupReader  *reader,
                  GCancellable   *cancellable,
                  Key            *key,
                  GError        **error)
{
  const gchar *value;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRING, "value", &value,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  if (strinfo_builder_contains (key->strinfo, value))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<choice value='%s'/> already given", value);
      return FALSE;
    }

  strinfo_builder_append_item (key->strinfo, value, 0);
  key->has_choices = TRUE;

  return g_markup_reader_expect_end (reader, cancellable, error);
}

static gboolean
key_parse_choices (GMarkupReader  *reader,
                   GCancellable   *cancellable,
                   Key            *key,
                   GError        **error)
{
  if (!g_markup_reader_collect_attributes (reader, error, G_MARKUP_COLLECT_INVALID, NULL))
    return FALSE;

  if (!key->type_string || (!g_str_equal (key->type_string, "s") &&
                            !g_str_equal (key->type_string, "as") &&
                            !g_str_equal (key->type_string, "ms")))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<choices> only allowed for keys with type 's', 'as' or 'ms'");
      return FALSE;
    }

  key->strinfo = g_string_new (NULL);

  if (!g_markup_reader_collect_elements (reader, cancellable, key, error, "choice", key_parse_choice, NULL))
    return FALSE;

  if (!key->has_choices)
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<choices> must contain at least one <choice>");
      return FALSE;
    }

  return TRUE;
}

static gboolean
key_parse_aliases (GMarkupReader  *reader,
                   GCancellable   *cancellable,
                   Key            *key,
                   GError        **error)
{
  return TRUE;
}

static gboolean
ignore_text (GMarkupReader  *reader,
             GCancellable   *cancellable,
             gpointer        user_data,
             GError        **error)
{
  while (g_markup_reader_advance (reader, cancellable, error) && g_markup_reader_is_text (reader))
    ;

  if (g_markup_reader_is_end_element (reader))
    return TRUE;

  g_markup_reader_unexpected (reader, error);

  return FALSE;
}

static gboolean
key_parse (GMarkupReader  *reader,
           GCancellable   *cancellable,
           Schema         *schema,
           GError        **error)
{
  Key *key;

  g_assert (g_markup_reader_is_start_element (reader, "key"));

  key = g_slice_new0 (Key);
  key->schema = schema;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRDUP,
                                             "name", &key->name,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "type", &key->type_string,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "enum", &key->enum_name,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "flags", &key->flags_name,
                                           G_MARKUP_COLLECT_INVALID))
    goto error;

  if ((key->type_string != NULL) + (key->enum_name != NULL) + (key->flags_name != NULL) != 1)
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_MISSING_ATTRIBUTE,
                   _("exactly one of 'type', 'enum' or 'flags' must be specified as an attribute to <key>"));
      return FALSE;
    }

  if (key->type_string)
    {
      if (!g_variant_type_string_is_valid (key->type_string))
        {
          g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                       _("invalid GVariant type string '%s'"), key->type_string);
          return FALSE;
        }

      key->type = g_variant_type_new (key->type_string);
    }
  else if (key->enum_name)
    key->type = g_variant_type_copy (G_VARIANT_TYPE_STRING);
  else /* flags */
    key->type = g_variant_type_copy (G_VARIANT_TYPE_STRING_ARRAY);

  if (!g_markup_reader_collect_elements (reader, cancellable, key, error,
                                         "summary",     ignore_text,
                                         "description", ignore_text,
                                         "default",     key_parse_default,
                                         "range",       key_parse_range,
                                         "choices",     key_parse_choices,
                                         "aliases",     key_parse_aliases,
                                         NULL))
    goto error;

  if (!schema_add_key (schema, reader, key->name, key, error))
    goto error;

  return TRUE;

error:
  return FALSE;
}

/* <schema> {{{1 */

struct _Override
{
  Schema       *schema;
  gchar        *name;

  gchar        *text;
  gchar        *context;
  gchar        *l10n;
};

static void
override_free (gpointer data)
{
  Override *override = data;

  g_free (override->name);
  g_free (override->text);
  g_free (override->context);
  g_free (override->l10n);

  g_slice_free (Override, override);
}

struct _Schema
{
  Dir          *dir;
  gchar        *id;

  gboolean      has_translated;
  gboolean      resolved;

  gchar        *gettext_domain;
  gchar        *path;

  const gchar  *extends_name;
  Schema       *extends;
  const gchar  *list_of_name;
  Schema       *list_of;

  GHashTable   *children_names;
  GHashTable   *children;
  GHashTable   *keys;
  GHashTable   *overrides;
};

static void
schema_free (gpointer data)
{
  Schema *schema = data;

  g_slice_free (Schema, schema);
}

static gboolean
schema_resolve (Schema  *schema,
                GError **error)
{
  static GSList *now_resolving; /* we don't unwind this properly in case of error */
  GSList me = { schema };

  if (schema->resolved)
    return TRUE;

  if (g_slist_find (now_resolving, schema))
    {
      GSList *node;
      GString *str;

      /* We have a reference cycle. */
      str = g_string_new ("Reference cycle detected: '%s'");
      for (node = now_resolving; node; node = node->next)
        {
          Schema *s = node->data;

          g_string_append_printf (str, "<- '%s'", s->id);

          /* Stop once we get back to ourselves. */
          if (s == schema)
            break;
        }

      g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, str->str);
      g_string_free (str, TRUE);
      return FALSE;
    }

  me.next = now_resolving;
  now_resolving = &me;

  if (schema->extends_name)
    {
      schema->extends = dir_resolve_schema (schema->dir, schema->extends_name,
                                            "extends", "reference", schema->id,
                                            error);
      if (!schema->extends)
        return FALSE;
    }

  if (schema->list_of_name)
    {
      schema->list_of = dir_resolve_schema (schema->dir, schema->list_of_name,
                                            "list-of", "reference", schema->id,
                                            error);
      if (!schema->list_of)
        return FALSE;
    }

  if (schema->children_names)
    {
      GHashTableIter iter;
      gpointer name, id;

      schema->children = g_hash_table_new (g_str_hash, g_str_equal);

      g_hash_table_iter_init (&iter, schema->children_names);
      while (g_hash_table_iter_next (&iter, &name, &id))
        {
          Schema *child;

          child = dir_resolve_schema (schema->dir, id,
                                      name, "child", schema->id,
                                      error);
          if (!child)
            return FALSE;

          g_hash_table_insert (schema->children, name, child);
        }
    }

  if (schema->keys)
    {
      GHashTableIter iter;
      gpointer key;

      g_hash_table_iter_init (&iter, schema->keys);
      while (g_hash_table_iter_next (&iter, NULL, &key))
        if (!key_resolve (key, error))
          return FALSE;
    }

  now_resolving = me.next;

  return TRUE;
}

static Enum *
schema_resolve_enum (Schema       *schema,
                     const gchar  *id,
                     gboolean      is_flags,
                     const gchar  *for_key,
                     GError      **error)
{
  return dir_resolve_enum (schema->dir, id, is_flags, for_key, schema->id, error);
}

static gboolean
schema_add_key (Schema         *schema,
                GMarkupReader  *reader,
                const gchar    *name,
                Key            *key,
                GError        **error)
{
  if (g_hash_table_contains (schema->keys, name))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<key name='%s'/> already defined in <schema id='%s'/>", name, schema->id);
      return FALSE;
    }

  g_hash_table_insert (schema->keys, g_strdup (name), key);

  return TRUE;
}

static gboolean
schema_parse_child (GMarkupReader  *reader,
                    GCancellable   *cancellable,
                    Schema         *schema,
                    GError        **error)
{
  const gchar *name, *schema_id;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRING, "name", &name,
                                           G_MARKUP_COLLECT_STRING, "schema", &schema_id,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  if (g_hash_table_contains (schema->children_names, name))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<child name='%s'/> appears twice in <schema id='%s'/>",
                   name, schema->id);
      return FALSE;
    }

  g_hash_table_insert (schema->children_names, g_strdup (name), g_strdup (schema_id));

  if (!g_markup_reader_expect_end (reader, cancellable, error))
    return FALSE;

  return TRUE;
}

static gboolean
schema_parse_override (GMarkupReader  *reader,
                       GCancellable   *cancellable,
                       Schema         *schema,
                       GError        **error)
{
  Override *override;

  override = g_slice_new0 (Override);
  override->schema = schema;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRING, "name", &override->name,
                                           G_MARKUP_COLLECT_STRING, "l10n", &override->l10n,
                                           G_MARKUP_COLLECT_STRING, "context", &override->context,
                                           G_MARKUP_COLLECT_INVALID))
    goto error;

  if (schema->overrides == NULL)
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<override name='%s'/> appears within <schema id='%s'/> that is not extending another",
                   override->name, schema->id);
      goto error;
    }

  if (g_hash_table_contains (schema->overrides, override->name))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<override name='%s'/> appears twice in <schema id='%s'/>", override->name, schema->id);
      return FALSE;
    }

  override->text = g_markup_reader_collect_text (reader, cancellable, error);
  if (!override->text)
    goto error;

  g_hash_table_insert (schema->overrides, g_strdup (override->name), override);

  return TRUE;

error:
  override_free (override);
  return FALSE;
}

static gboolean
schema_parse (GMarkupReader  *reader,
              GCancellable   *cancellable,
              Dir            *dir,
              GError        **error)
{
  Schema *schema;

  g_assert (g_markup_reader_is_start_element (reader, "schema"));

  schema = g_slice_new0 (Schema);
  schema->dir = dir;
  schema->keys = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, key_free);
  schema->children_names = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRDUP,
                                             "id", &schema->id,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "path", &schema->path,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "gettext-domain", &schema->gettext_domain,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "extends", &schema->extends_name,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "list-of", &schema->list_of_name,
                                           G_MARKUP_COLLECT_INVALID))
    goto error;

  if (schema->extends_name)
    schema->overrides = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, override_free);

  if (!g_markup_reader_collect_elements (reader, cancellable, schema, error,
                                         "key",      key_parse,
                                         "child",    schema_parse_child,
                                         "override", schema_parse_override,
                                         NULL))
    goto error;

  if (!dir_add_schema (dir, reader, schema->id, schema, error))
    goto error;

  return TRUE;

error:
  return FALSE;
}

/* Directory handling {{{1 */

struct _Dir
{
  Dir          *parent_dir;
  const gchar  *path;
  GHashTable   *excludes;
  gboolean      parsed;

  /* temporarily set while parsing <schemalist> */
  gchar        *gettext_domain;

  GHashTable   *schemas;
  GHashTable   *enums;
};

static gboolean
dir_add_enum (Dir            *dir,
              GMarkupReader  *reader,
              const gchar    *id,
              Enum           *enum_,
              GError        **error)
{
  if (g_hash_table_contains (dir->enums, id))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<enum id='%s'/> or <flags id='%s'/> already defined in directory %s",
                   id, id, dir->path);
      return FALSE;
    }

  g_hash_table_insert (dir->enums, g_strdup (id), enum_);

  return TRUE;
}

static gboolean
dir_add_schema (Dir            *dir,
                GMarkupReader  *reader,
                const gchar    *id,
                Schema         *schema,
                GError        **error)
{
  if (g_hash_table_contains (dir->schemas, id))
    {
      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
                   "<schema id='%s'/> already defined in directory %s", id, dir->path);
      return FALSE;
    }

  g_hash_table_insert (dir->schemas, g_strdup (id), schema);

  return TRUE;
}

static gboolean
dir_parse_schemalist (GMarkupReader  *reader,
                      GCancellable   *cancellable,
                      Dir            *dir,
                      GError        **error)
{
  gboolean ok;

  if (!g_markup_reader_collect_attributes (reader, error,
                                           G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
                                             "gettext-domain", &dir->gettext_domain,
                                           G_MARKUP_COLLECT_INVALID))
    return FALSE;

  ok = g_markup_reader_collect_elements (reader, cancellable, dir, error,
                                         "schema", schema_parse, "enum", enum_parse, "flags", enum_parse, NULL);

  g_free (dir->gettext_domain);
  dir->gettext_domain = NULL;

  return ok;
}

static gboolean
dir_parse_one_file (Dir          *dir,
                    const gchar  *filename,
                    GCancellable *cancellable,
                    GError      **error)
{
  GFileInputStream *stream;
  GMarkupReader *reader;
  GFile *file;
  gboolean ok;

  file = g_file_new_for_path (filename);
  stream = g_file_read (file, cancellable, error);
  g_object_unref (file);

  if (!stream)
    return FALSE;

  reader = g_markup_reader_new (G_INPUT_STREAM (stream),
                                G_MARKUP_PREFIX_ERROR_POSITION |
                                G_MARKUP_TREAT_CDATA_AS_TEXT |
                                G_MARKUP_IGNORE_QUALIFIED |
                                G_MARKUP_IGNORE_PASSTHROUGH);
  g_object_unref (stream);

  ok = g_markup_reader_collect_elements (reader, cancellable, dir, error, "schemalist", dir_parse_schemalist, NULL);

  g_object_unref (reader);

  if (!ok)
    g_prefix_error (error, "%s: ", filename);

  return ok;
}

static Dir *compile_dir;

static gboolean
dir_parse (Dir           *dir,
           GCancellable  *cancellable,
           GError       **error)
{
  GError *local_error = NULL;
  gboolean ok = TRUE;
  const gchar *name;
  GDir *dirp;

  g_assert (!dir->parsed);

  dirp = g_dir_open (dir->path, 0, &local_error);

  dir->schemas = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, schema_free);
  dir->enums = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, enum_free);

  if (!dirp)
    {
      /* If we get a G_FILE_ERROR_NOENT then ignore it, unless it was
       * for the toplevel directory (ie: the one we were asked to
       * compile).
       */
      if (g_error_matches (local_error, G_FILE_ERROR, G_FILE_ERROR_NOENT) && dir != compile_dir)
        {
          g_error_free (local_error);
          return TRUE;
        }

      g_propagate_error (error, local_error);
      return FALSE;
    }

  while (ok && (name = g_dir_read_name (dirp)))
    {
      gchar *fullname;

      if (!g_str_has_suffix (name, ".xml"))
        continue;

      if (dir->excludes && g_hash_table_contains (dir->excludes, name))
        continue;

      fullname = g_build_filename (dir->path, name, NULL);
      ok = dir_parse_one_file (dir, fullname, cancellable, error);
      g_free (fullname);
    }

  g_dir_close (dirp);

  dir->parsed = ok;

  return ok;
}

static Dir *
dir_new (const gchar *path,
         Dir         *parent_dir)
{
  Dir *dir;

  dir = g_slice_new0 (Dir);
  dir->path = path;
  dir->parent_dir = parent_dir;

  return dir;
}

static void
setup_compile_dir (const gchar         *directory,
                   const gchar * const *excluded)
{
  const gchar * const * system_dirs;
  gint i, n;

  /* If we are compiling a system directory we want to include all of
   * the directories that come before it.
   *
   * If we are compiling a non-system directory then we want to include
   * all of the system directories before it.
   *
   * For example, of XDG_DATA_DIRS=/a:/b:/c then:
   *
   *  - for building /a, we want a path of /a, /b, /c
   *
   *  - for building /b, we want a path of /b, /c
   *
   *  - for building /c, we want a path of /c
   *
   *  - for building /x we want a path of /x, /a, /b, /c
   */
  system_dirs = g_get_system_data_dirs ();
  n = g_strv_length ((gchar **) system_dirs);

  /* We're building a linked list -- start at the end */
  for (i = n - 1; i >= 0; i--)
    {
      /* If we see our own directory then stop -- we don't want any more
       * system dirs.  We will deal with our directory below.
       */
      if (g_str_equal (system_dirs[i], directory))
        break;

      compile_dir = dir_new (system_dirs[i], compile_dir);
    }

  compile_dir = dir_new (directory, compile_dir);
}

Schema *
dir_resolve_schema (Dir          *dir,
                    const gchar  *id,
                    const gchar  *detail,
                    const gchar  *purpose,
                    const gchar  *caller,
                    GError      **error)
{
  Schema *schema = NULL;
  Dir *d;

  g_assert (dir);

  for (d = dir; d; d = d->parent_dir)
    {
      if (!dir->parsed)
        if (!dir_parse (dir, NULL, error))
          return FALSE;

      schema = g_hash_table_lookup (dir->schemas, id);

      if (schema)
        break;
    }

  if (!schema)
    {
      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                   "Unable to locate schema '%s' needed for '%s' %s of %s",
                   id, detail, purpose, caller);
      return NULL;
    }

  if (!schema_resolve (schema, error))
    return NULL;

  return schema;
}

Enum *
dir_resolve_enum (Dir          *dir,
                  const gchar  *id,
                  gboolean      is_flags,
                  const gchar  *for_key,
                  const gchar  *of_schema,
                  GError      **error)
{
  Enum *enum_ = NULL;
  Dir *d;

  g_assert (dir);

  for (d = dir; d; d = d->parent_dir)
    {
      if (!dir->parsed)
        if (!dir_parse (dir, NULL, error))
          return FALSE;

      enum_ = g_hash_table_lookup (dir->enums, id);

      if (enum_)
        break;
    }

  if (!enum_ || enum_->is_flags != is_flags)
    {
      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                   "Unable to locate <%s id='%s'/> needed for key '%s' of schema '%s'",
                   is_flags ? "flags" : "enum", id, for_key, of_schema);
      return NULL;
    }

  return enum_;
}

static gboolean
dir_resolve (Dir     *dir,
             GError **error)
{
  GHashTableIter iter;
  gpointer schema;

  if (!dir_parse (dir, NULL, error))
    return FALSE;

  g_hash_table_iter_init (&iter, dir->schemas);
  while (g_hash_table_iter_next (&iter, NULL, &schema))
    if (!schema_resolve (schema, error))
      return FALSE;

  return TRUE;
}

static GVariant *
key_compile (Key     *key,
             GError **error)
{
  GVariantBuilder builder;

  g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);

  return g_variant_builder_end (&builder);
}

static GHashTable *
schema_compile (Schema  *schema,
                GError **error)
{
  GHashTable *compiled_schema;
  GvdbItem *root_item;
  GHashTableIter iter;
  gpointer key, name;
  gpointer id;

  compiled_schema = gvdb_hash_table_new (NULL, NULL);
  root_item = gvdb_hash_table_insert (compiled_schema, "");

  if (schema->path)
    gvdb_hash_table_insert_string (compiled_schema, ".path", schema->path);

  if (schema->list_of)
    gvdb_hash_table_insert_string (compiled_schema, ".list-of", schema->list_of_name);

  if (schema->extends)
    gvdb_hash_table_insert_string (compiled_schema, ".extends", schema->extends_name);

  /* Only store the gettext domain if a key was actually translated */
  if (schema->has_translated)
    gvdb_hash_table_insert_string (compiled_schema, ".gettext-domain", schema->gettext_domain);

  g_hash_table_iter_init (&iter, schema->keys);
  while (g_hash_table_iter_next (&iter, &name, &key))
    {
      GVariant *compiled_key;
      GvdbItem *key_item;

      compiled_key = key_compile (key, error);
      if (!compiled_key)
        goto error;

      key_item = gvdb_hash_table_insert (compiled_schema, name);
      gvdb_item_set_parent (key_item, root_item);
      gvdb_item_set_value (key_item, compiled_key);
    }

  g_hash_table_iter_init (&iter, schema->children);
  while (g_hash_table_iter_next (&iter, &name, &id))
    {
      GvdbItem *child_item;

      child_item = gvdb_hash_table_insert (compiled_schema, name);
      gvdb_item_set_parent (child_item, root_item);
      gvdb_item_set_value (child_item, g_variant_new_string (id));
    }

  return compiled_schema;
error:
  g_assert_not_reached ();
}

static GHashTable *
dir_compile (Dir     *dir,
             GError **error)
{
  GHashTable *compiled_dir;
  GvdbItem *root_item;
  GHashTableIter iter;
  gpointer schema, id;

  compiled_dir = gvdb_hash_table_new (NULL, NULL);
  root_item = gvdb_hash_table_insert (compiled_dir, "");

  g_hash_table_iter_init (&iter, dir->schemas);
  while (g_hash_table_iter_next (&iter, &id, &schema))
    {
      GHashTable *compiled_schema;
      GvdbItem *schema_item;

      compiled_schema = schema_compile (schema, error);
      if (!compiled_schema)
        goto error;

      schema_item = gvdb_hash_table_insert (compiled_dir, id);
      gvdb_item_set_parent (schema_item, root_item);
      gvdb_item_set_hash_table (schema_item, compiled_schema);
    }

  return compiled_dir;
error:
  g_assert_not_reached ();
}

int
main (void)
{
  GError *error = NULL;
  setup_compile_dir ("/home/desrt/.cache/jhbuild/install/share/glib-2.0/schemas", NULL);
  if (!dir_resolve (compile_dir, &error))
    g_printerr ("%s\n", error->message);
  return error ? 1 : 0;
}

/* Epilogue {{{1 */

/* vim:set foldmethod=marker: */