/*

 * Copyright (C) 2010, 2011 Igalia S.L.

 * Copyright (C) 2011 Intel Corporation.

 *

 * Contact: Iago Toral Quiroga <itoral@igalia.com>

 *

 * 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; 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, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

 * 02110-1301 USA

 *

 */

/**

 * SECTION:grl-registry

 * @short_description: Grilo plugins loader and manager

 * @see_also: #GrlPlugin, #GrlSource

 *

 * The registry holds the metadata of a set of plugins.

 *

 * The #GrlRegistry object is a list of plugins and some functions

 * for dealing with them. Each #GrlPlugin is matched 1-1 with a file

 * on disk, and may or may not be loaded a given time. There only can be

 * a single instance of #GrlRegistry (singleton pattern).

 *

 * A #GrlPlugin can hold several data #GrlSource sources, and #GrlRegistry

 * shall register each one of them.

 */

#include "grl-registry.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "grl-registry-priv.h"

#include "grl-plugin-priv.h"

#include "grl-log.h"

#include "grl-error.h"

#include <glib/gi18n-lib.h>

#include <string.h>

#include <gmodule.h>

#include <libxml/parser.h>

#define GRL_LOG_DOMAIN_DEFAULT  registry_log_domain

GRL_LOG_DOMAIN(registry_log_domain);

#define XML_ROOT_ELEMENT_NAME "plugin"

#define GRL_PLUGIN_INFO_SUFFIX "xml"

#define GRL_PLUGIN_INFO_MODULE "module"

#define LOCAL_NET_TAG      "net:local"

#define INTERNET_NET_TAG   "net:internet"

#define SET_INVISIBLE_SOURCE(src, val)                          \

  g_object_set_data(G_OBJECT(src), "invisible", GINT_TO_POINTER(val))

#define SOURCE_IS_INVISIBLE(src)                                \

  GPOINTER_TO_INT(g_object_get_data(G_OBJECT(src), "invisible"))

/* GQuark-like implementation, where we manually assign the first IDs. */

struct KeyIDHandler {

  GHashTable *string_to_id;

  GArray *id_to_string;

  gint last_id;

};

struct _GrlRegistryPrivate {

  GHashTable *configs;

  GHashTable *plugins;

  GHashTable *sources;

  GHashTable *related_keys;

  GHashTable *system_keys;

  GHashTable *ranks;

  GSList *plugins_dir;

  GSList *allowed_plugins;

  gboolean all_plugins_preloaded;

  struct KeyIDHandler key_id_handler;

  GNetworkMonitor *netmon;

};

static void grl_registry_setup_ranks (GrlRegistry *registry);

static void key_id_handler_init (struct KeyIDHandler *handler);

static void key_id_handler_free (struct KeyIDHandler *handler);

static GrlKeyID key_id_handler_get_key (struct KeyIDHandler *handler,

                                        const gchar *key_name);

static const gchar *key_id_handler_get_name (struct KeyIDHandler *handler,

                                             GrlKeyID key);

static GrlKeyID key_id_handler_add (struct KeyIDHandler *handler,

                                    GrlKeyID key, const gchar *key_name);

static gboolean param_spec_is_equal (GParamSpec *curr, GParamSpec *new);

static void shutdown_plugin (GrlPlugin *plugin);

static void configs_free (GList *configs);

static GrlPlugin *grl_registry_prepare_plugin (GrlRegistry *registry,

                                               const gchar *library_filename,

                                               GError **error);

/* ================ GrlRegistry GObject ================ */

enum {

  SIG_SOURCE_ADDED,

  SIG_SOURCE_REMOVED,

  SIG_METADATA_KEY_ADDED,

  SIG_LAST

};

static gint registry_signals[SIG_LAST];

G_DEFINE_TYPE_WITH_PRIVATE (GrlRegistry, grl_registry, G_TYPE_OBJECT);

static void

grl_registry_class_init (GrlRegistryClass *klass)

{

  /**

   * GrlRegistry::source-added:

   * @registry: the registry

   * @source: the source that has been added

   *

   * Signals that a source has been added to the registry.

   *

   * Since: 0.2.0

   */

  registry_signals[SIG_SOURCE_ADDED] =

    g_signal_new("source-added",

		 G_TYPE_FROM_CLASS(klass),

		 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

		 0,

		 NULL,

		 NULL,

		 g_cclosure_marshal_VOID__OBJECT,

		 G_TYPE_NONE, 1, GRL_TYPE_SOURCE);

  /**

   * GrlRegistry::source-removed:

   * @registry: the registry

   * @source: the source that has been removed

   *

   * Signals that a source has been removed from the registry.

   *

   * Since: 0.2.0

   */

  registry_signals[SIG_SOURCE_REMOVED] =

    g_signal_new("source-removed",

		 G_TYPE_FROM_CLASS(klass),

		 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

		 0,

		 NULL,

		 NULL,

		 g_cclosure_marshal_VOID__OBJECT,

		 G_TYPE_NONE, 1, GRL_TYPE_SOURCE);

  /**

   * GrlRegistry::metadata-key-added:

   * @registry: the registry

   * @key: the name of the new key added

   *

   * Signals that a new metadata key has been registered.

   *

   * Since: 0.2.10

   */

  registry_signals[SIG_METADATA_KEY_ADDED] =

    g_signal_new("metadata-key-added",

                 G_TYPE_FROM_CLASS(klass),

                 G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

                 0,

                 NULL,

                 NULL,

                 g_cclosure_marshal_VOID__STRING,

                 G_TYPE_NONE, 1, G_TYPE_STRING);

}

static void

get_connectivity (GrlRegistry          *registry,

                  GNetworkConnectivity *connectivity,

                  gboolean             *network_available)

{

  g_assert (connectivity != NULL);

  g_assert (network_available != NULL);

  if (g_getenv("GRL_NET_MOCKED") != NULL) {

    GRL_DEBUG ("Mocked network, assuming network is available and connectivity "

               "level is FULL");

    *connectivity = G_NETWORK_CONNECTIVITY_FULL;

    *network_available = TRUE;

  } else {

    g_object_get (G_OBJECT (registry->priv->netmon),

                  "connectivity", connectivity,

                  "network-available", network_available,

                  NULL);

    GRL_DEBUG ("Connectivity level is %d, Network is %s",

               *connectivity, *network_available ? "available" : "unavailable");

  }

}

static void

network_changed_cb (GObject     *gobject,

                    GParamSpec  *pspec,

                    GrlRegistry *registry)

{

  GNetworkConnectivity connectivity;

  gboolean network_available;

  GHashTableIter iter;

  GrlSource *current_source;

  GRL_DEBUG ("Network availability changed");

  get_connectivity (registry, &connectivity, &network_available);

  if (!network_available) {

    g_hash_table_iter_init (&iter, registry->priv->sources);

    while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &current_source)) {

      const char **tags = grl_source_get_tags (current_source);

      if (!tags)

        continue;

      if ((g_strv_contains (tags, LOCAL_NET_TAG) ||

           g_strv_contains (tags, INTERNET_NET_TAG)) &&

          !SOURCE_IS_INVISIBLE(current_source)) {

        GRL_DEBUG ("Network isn't available for '%s', hiding",

                   grl_source_get_id (current_source));

        SET_INVISIBLE_SOURCE(current_source, TRUE);

        g_signal_emit (registry, registry_signals[SIG_SOURCE_REMOVED], 0, current_source);

      }

    }

  } else {

    g_hash_table_iter_init (&iter, registry->priv->sources);

    while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &current_source)) {

      const char **tags = grl_source_get_tags (current_source);

      if (!tags)

        continue;

      if (g_strv_contains (tags, LOCAL_NET_TAG) &&

          SOURCE_IS_INVISIBLE(current_source)) {

        GRL_DEBUG ("Local network became available for '%s', showing",

                   grl_source_get_id (current_source));

        SET_INVISIBLE_SOURCE(current_source, FALSE);

        g_signal_emit (registry, registry_signals[SIG_SOURCE_ADDED], 0, current_source);

      }

      if (g_strv_contains (tags, INTERNET_NET_TAG) &&

          connectivity == G_NETWORK_CONNECTIVITY_FULL &&

          SOURCE_IS_INVISIBLE(current_source)) {

        GRL_DEBUG ("Internet became available for '%s', showing",

                   grl_source_get_id (current_source));

        SET_INVISIBLE_SOURCE(current_source, FALSE);

        g_signal_emit (registry, registry_signals[SIG_SOURCE_ADDED], 0, current_source);

      }

      if (g_strv_contains (tags, INTERNET_NET_TAG) &&

          connectivity != G_NETWORK_CONNECTIVITY_FULL &&

          !SOURCE_IS_INVISIBLE(current_source)) {

        GRL_DEBUG ("Internet became unavailable for '%s', hiding",

                   grl_source_get_id (current_source));

        SET_INVISIBLE_SOURCE(current_source, TRUE);

        g_signal_emit (registry, registry_signals[SIG_SOURCE_REMOVED], 0, current_source);

      }

    }

  }

}

static void

grl_registry_init (GrlRegistry *registry)

{

  registry->priv = grl_registry_get_instance_private (registry);

  registry->priv->configs =

    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) configs_free);

  registry->priv->plugins =

    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);

  registry->priv->sources =

    g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

  registry->priv->related_keys =

    g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);

  registry->priv->system_keys =

    g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify) g_param_spec_unref);

  registry->priv->netmon = g_network_monitor_get_default ();

  g_signal_connect (G_OBJECT (registry->priv->netmon), "notify::connectivity",

                    G_CALLBACK (network_changed_cb), registry);

  g_signal_connect (G_OBJECT (registry->priv->netmon), "notify::network-available",

                    G_CALLBACK (network_changed_cb), registry);

  key_id_handler_init (&registry->priv->key_id_handler);

  grl_registry_setup_ranks (registry);

}

/* ================ Utitilies ================ */

static void

configs_free (GList *configs)

{

  g_list_free_full (configs, g_object_unref);

}

static void

update_source_visibility (GrlRegistry *registry,

                          GrlSource   *source)

{

  GNetworkConnectivity connectivity;

  gboolean network_available;

  const char **tags;

  gboolean needs_local, needs_inet;

  tags = grl_source_get_tags (source);

  if (!tags)

    return;

  needs_local = g_strv_contains (tags, LOCAL_NET_TAG);

  needs_inet = g_strv_contains (tags, INTERNET_NET_TAG);

  if (!needs_local &&

      !needs_inet)

    return;

  get_connectivity (registry, &connectivity, &network_available);

  GRL_DEBUG ("Source %s needs %s %s%s",

             grl_source_get_id (source),

             needs_local ? "local network" : "",

             needs_inet && needs_local ? " and " : "",

             needs_inet ? "Internet" : "");

  if (!network_available) {

    if (needs_local || needs_inet) {

      GRL_DEBUG ("Network isn't available for '%s', hiding",

                 grl_source_get_id (source));

      SET_INVISIBLE_SOURCE(source, TRUE);

    }

  } else {

    if (connectivity != G_NETWORK_CONNECTIVITY_FULL) {

      if (needs_inet) {

        GRL_DEBUG ("Internet isn't available for '%s', hiding",

                   grl_source_get_id (source));

        SET_INVISIBLE_SOURCE(source, TRUE);

      }

    }

  }

}

static void

config_source_rank (GrlRegistry *registry,

                    const gchar *source_id,

                    gint rank)

{

  GRL_DEBUG ("Rank configuration, '%s:%d'", source_id, rank);

  g_hash_table_insert (registry->priv->ranks,

                       g_strdup (source_id),

                       GINT_TO_POINTER (rank));

}

static void

set_source_rank (GrlRegistry *registry, GrlSource *source)

{

  gint rank;

  rank =

    GPOINTER_TO_INT (g_hash_table_lookup (registry->priv->ranks,

                                          grl_source_get_id (source)));

  if (!rank) {

    rank = GRL_RANK_DEFAULT;

  }

  g_object_set (source, "rank", rank, NULL);

  GRL_DEBUG ("Source rank '%s' : %d", grl_source_get_id (source), rank);

}

static void

grl_registry_setup_ranks (GrlRegistry *registry)

{

  const gchar *ranks_env;

  gchar **rank_specs;

  gchar **iter;

  registry->priv->ranks = g_hash_table_new_full (g_str_hash, g_str_equal,

						 g_free, NULL);

  ranks_env = g_getenv (GRL_PLUGIN_RANKS_VAR);

  if (!ranks_env) {

    GRL_DEBUG ("$%s is not set, using default ranks.", GRL_PLUGIN_RANKS_VAR);

    return;

  }

  rank_specs = g_strsplit (ranks_env, ",", 0);

  iter = rank_specs;

  while (*iter) {

    gchar **rank_info = g_strsplit (*iter, ":", 2);

    if (rank_info[0] && rank_info[1]) {

      gchar *tmp;

      gchar *id = rank_info[0];

      gchar *srank = rank_info[1];

      gint rank = (gint) g_ascii_strtoll (srank, &tmp, 10);

      if (*tmp != '\0') {

        GRL_WARNING ("Incorrect ranking definition: '%s'. Skipping...", *iter);

      } else {

        config_source_rank (registry, id, rank);

      }

    } else {

      GRL_WARNING ("Incorrect ranking definition: '%s'. Skipping...", *iter);

    }

    g_strfreev (rank_info);

    iter++;

  }

  g_strfreev (rank_specs);

}

static gint

compare_by_rank (gconstpointer a,

                 gconstpointer b) {

  gint rank_a;

  gint rank_b;

  rank_a = grl_source_get_rank (GRL_SOURCE (a));

  rank_b = grl_source_get_rank (GRL_SOURCE (b));

  return (rank_a < rank_b) - (rank_a > rank_b);

}

static gboolean

register_keys_plugin (GrlRegistry *registry,

                      GrlPlugin *plugin,

                      GError **error)

{

  gboolean is_loaded;

  /* Check if plugin is already loaded */

  g_object_get (plugin, "loaded", &is_loaded, NULL);

  if (is_loaded) {

    GRL_WARNING ("Plugin is already loaded: '%s'", grl_plugin_get_id (plugin));

    g_set_error (error,

                 GRL_CORE_ERROR,

                 GRL_CORE_ERROR_LOAD_PLUGIN_FAILED,

                 _("Plugin “%s” is already loaded"), grl_plugin_get_id (plugin));

    return FALSE;

  }

  grl_plugin_register_keys (plugin);

  return TRUE;

}

static gboolean

activate_plugin (GrlRegistry *registry,

                 GrlPlugin *plugin,

                 GError **error)

{

  GList *plugin_configs;

  plugin_configs = g_hash_table_lookup (registry->priv->configs,

                                        grl_plugin_get_id (plugin));

  if (!grl_plugin_load (plugin, plugin_configs)) {

    GRL_DEBUG ("Failed to initialize plugin from %s. Check if plugin is well configured", grl_plugin_get_filename (plugin));

    g_set_error (error,

                 GRL_CORE_ERROR,

                 GRL_CORE_ERROR_LOAD_PLUGIN_FAILED,

                 _("Failed to initialize plugin from %s"), grl_plugin_get_filename (plugin));

    shutdown_plugin (plugin);

    return FALSE;

  }

  GRL_DEBUG ("Loaded plugin '%s' from '%s'",

             grl_plugin_get_id (plugin),

             grl_plugin_get_filename (plugin));

  return TRUE;

}

static GrlKeyID

grl_registry_register_metadata_key_full (GrlRegistry *registry,

                                         GParamSpec *param_spec,

                                         GrlKeyID key,

                                         GrlKeyID bind_key,

                                         GError **error)

{

  GList *bound_partners;

  GList *partner;

  const gchar *key_name;

  g_return_val_if_fail (GRL_IS_REGISTRY (registry), 0);

  g_return_val_if_fail (G_IS_PARAM_SPEC (param_spec), 0);

  GrlKeyID registered_key;

  key_name = g_param_spec_get_name (param_spec);

  registered_key = key_id_handler_get_key (&registry->priv->key_id_handler, key_name);

  if (registered_key != GRL_METADATA_KEY_INVALID) {

    GParamSpec *key_spec = g_hash_table_lookup (registry->priv->system_keys,

                                                (gpointer) key_name);

    if (param_spec_is_equal (key_spec, param_spec)) {

      /* Key registered */

      GRL_DEBUG ("metadata key '%s' already registered with same spec", key_name);

      g_param_spec_unref (param_spec);

      return registered_key;

    } else {

      GRL_WARNING ("metadata key '%s' already exists", key_name);

      g_set_error (error,

                   GRL_CORE_ERROR,

                   GRL_CORE_ERROR_REGISTER_METADATA_KEY_FAILED,

                   _("Metadata key “%s” already registered in different format"),

                   key_name);

      return GRL_METADATA_KEY_INVALID;

    }

  }

  registered_key = key_id_handler_add (&registry->priv->key_id_handler, key, key_name);

  if (registered_key == GRL_METADATA_KEY_INVALID) {

    GRL_WARNING ("metadata key '%s' cannot be registered", key_name);

    g_set_error (error,

                 GRL_CORE_ERROR,

                 GRL_CORE_ERROR_REGISTER_METADATA_KEY_FAILED,

                 _("Metadata key “%s” cannot be registered"),

                 key_name);

    return GRL_METADATA_KEY_INVALID;

  }

  g_hash_table_insert (registry->priv->system_keys,

                       (gpointer) key_name,

                       param_spec);

  if (bind_key == GRL_METADATA_KEY_INVALID) {

  /* Key is only related to itself */

    g_hash_table_insert (registry->priv->related_keys,

                         GRLKEYID_TO_POINTER (registered_key),

                         g_list_prepend (NULL,

                                         GRLKEYID_TO_POINTER (registered_key)));

  } else {

    /* Add the new key to the partners */

    bound_partners = g_hash_table_lookup (registry->priv->related_keys, GRLKEYID_TO_POINTER (bind_key));

    bound_partners = g_list_append (bound_partners, GRLKEYID_TO_POINTER (registered_key));

    for (partner = bound_partners;

         partner;

         partner = g_list_next (partner)) {

      g_hash_table_insert (registry->priv->related_keys,

                           partner->data,

                           bound_partners);

    }

  }

  return registered_key;

}

G_GNUC_INTERNAL GrlKeyID

grl_registry_register_metadata_key_for_type (GrlRegistry *registry,

                                             const gchar *key_name,

                                             GType type)

{

  GParamSpec *spec;

  switch (type) {

  case G_TYPE_INT:

    spec = g_param_spec_int (key_name,

                             key_name,

                             key_name,

                             0, G_MAXINT,

                             0,

                             G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    break;

  case G_TYPE_INT64:

    spec = g_param_spec_int64 (key_name,

                               key_name,

                               key_name,

                               -1, G_MAXINT64,

                               -1,

                               G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    break;

  case G_TYPE_STRING:

    spec = g_param_spec_string (key_name,

                                key_name,

                                key_name,

                                NULL,

                                G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    break;

  case G_TYPE_BOOLEAN:

    spec = g_param_spec_boolean (key_name,

                                 key_name,

                                 key_name,

                                 FALSE,

                                 G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    break;

  case G_TYPE_FLOAT:

    spec = g_param_spec_float (key_name,

                               key_name,

                               key_name,

                               0, G_MAXFLOAT,

                               0,

                               G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    break;

  default:

    if (type == G_TYPE_DATE_TIME) {

        spec = g_param_spec_boxed (key_name,

                                   key_name,

                                   key_name,

                                   G_TYPE_DATE_TIME,

                                   G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);

    } else {

      GRL_WARNING ("'%s' is being ignored as G_TYPE '%s' is not being handled",

                   key_name, G_VALUE_TYPE_NAME (type));

      return GRL_METADATA_KEY_INVALID;

    }

  }

  return grl_registry_register_metadata_key (registry, spec, GRL_METADATA_KEY_INVALID, NULL);

}

static void

key_id_handler_init (struct KeyIDHandler *handler)

{

  const gchar *null_string = NULL;

  handler->string_to_id = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

  handler->id_to_string = g_array_new (FALSE, /* zero terminated */

                                       TRUE,  /* zero-initialised */

                                       sizeof (const gchar *));

  /* We want indices in ->id_to_string to start from 1, so we add a NULL entry

   * for GRL_METADATA_KEY_INVALID (i.e. 0) */

  g_array_insert_val (handler->id_to_string,

                      GRL_METADATA_KEY_INVALID,

                      null_string);

}

static void

key_id_handler_free (struct KeyIDHandler *handler)

{

  g_hash_table_unref (handler->string_to_id);

  g_array_unref (handler->id_to_string);

}

static

GrlKeyID key_id_handler_get_key (struct KeyIDHandler *handler, const gchar *key_name)

{

  gpointer val = g_hash_table_lookup (handler->string_to_id, key_name);

  if (val == NULL)

    return GRL_METADATA_KEY_INVALID;

  return GRLPOINTER_TO_KEYID (val);

}

static const gchar *

key_id_handler_get_name (struct KeyIDHandler *handler, GrlKeyID key)

{

  if (key < handler->id_to_string->len)

    return g_array_index (handler->id_to_string, const gchar *, key);

  return NULL;

}

/*

 * key_id_handler_add:

 * @handler: the handler

 * @key: a specific key for system keys, or GRL_METADATA_KEY_INVALID for it to

 * be assigned

 * @name: the name of the key.

 *

 * Add a new key<->name correspondence.

 *

 * Returns: the new key number, or GRL_METADATA_KEY_INVALID if the key could

 * not be created (typically if @key or @name is already registered).

 */

static GrlKeyID

key_id_handler_add (struct KeyIDHandler *handler, GrlKeyID key, const gchar *name)

{

  GrlKeyID _key = key;

  if (_key == GRL_METADATA_KEY_INVALID) {

    /* existing keys go from 1 to (id_to_string->len - 1), so the next

     * available key is id_to_string->len, which will be incremented by

     * g_array_insert_val() */

    _key = handler->id_to_string->len;

  }

  if (NULL != key_id_handler_get_name (handler, _key)) {

    GRL_WARNING ("Cannot register %d:%s because key is already defined as %s",

                 _key, name, key_id_handler_get_name (handler, _key));

    return GRL_METADATA_KEY_INVALID;

  } else if ( GRL_METADATA_KEY_INVALID != key_id_handler_get_key (handler, name)) {

    /* _key or name is already in use! */

    GRL_WARNING ("Cannot register %d:%s because name is already registered with key %d",

                 _key, name, key_id_handler_get_key (handler, name));

    return GRL_METADATA_KEY_INVALID;

  } else {

    /* name_copy is shared between handler->id_to_string and

     * handler->string_to_id */

    gchar *name_copy = g_strdup (name);

    if (_key >= handler->id_to_string->len)

      g_array_set_size (handler->id_to_string, _key + 1);

    /* yes, g_array_index() is a macro that give you an lvalue */

    g_array_index (handler->id_to_string, const gchar *, _key) = name_copy;

    g_hash_table_insert (handler->string_to_id,

                         name_copy, GRLKEYID_TO_POINTER (_key));

  }

  return _key;

}

static GList *

key_id_handler_get_all_keys (struct KeyIDHandler *handler)

{

  return g_hash_table_get_values (handler->string_to_id);

}

#define CHECK_NUMERIC_PARAM_SPEC_LIMITS(is_type, cast_type, a, b) {     \

  if (is_type) {                                                        \

    if ((cast_type(a))->maximum != (cast_type(b))->maximum ||           \

        (cast_type(a))->minimum != (cast_type(b))->minimum ||           \

        (cast_type(a))->default_value != (cast_type(b))->default_value) \

      return FALSE;                                                     \

    return TRUE;                                                        \

  }                                                                     \

}

/* @curr: The current spec we have

 * @new: The spec to match

 *

 * Returns: true if specs are the same, false otherwise.

 */

static gboolean

param_spec_is_equal (GParamSpec *cur,

                     GParamSpec *new)

{

  GType ctype = G_PARAM_SPEC_TYPE (cur);

  if (ctype != G_PARAM_SPEC_TYPE (new))

    return FALSE;

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_INT),

                                   G_PARAM_SPEC_INT, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_LONG),

                                   G_PARAM_SPEC_LONG, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_INT64),

                                   G_PARAM_SPEC_INT64, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_CHAR),

                                   G_PARAM_SPEC_CHAR, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_UINT),

                                   G_PARAM_SPEC_UINT, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_ULONG),

                                   G_PARAM_SPEC_ULONG, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_UINT64),

                                   G_PARAM_SPEC_UINT64, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_UCHAR),

                                   G_PARAM_SPEC_UCHAR, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_FLOAT),

                                   G_PARAM_SPEC_FLOAT, cur, new);

  CHECK_NUMERIC_PARAM_SPEC_LIMITS ((ctype == G_TYPE_PARAM_DOUBLE),

                                   G_PARAM_SPEC_DOUBLE, cur, new);

  if (ctype == G_TYPE_PARAM_STRING) {

    GParamSpecString *c = G_PARAM_SPEC_STRING (cur);

    GParamSpecString *n = G_PARAM_SPEC_STRING (new);

    return (g_strcmp0 (c->default_value, n->default_value) == 0);

  } else if (ctype == G_TYPE_PARAM_ENUM) {

    GParamSpecEnum *c = G_PARAM_SPEC_ENUM (cur);

    GParamSpecEnum *n = G_PARAM_SPEC_ENUM (new);

    if (c->default_value != n->default_value ||

        cur->value_type != new->value_type) {

      GRL_DEBUG ("%s differ (values: %d and %d) (types: %s and %s)",

                 g_type_name (ctype), c->default_value, n->default_value,

                 g_type_name (cur->value_type), g_type_name (new->value_type));

      return FALSE;

    }

  } else if (ctype == G_TYPE_PARAM_FLAGS) {

    GParamSpecFlags *c = G_PARAM_SPEC_FLAGS (cur);

    GParamSpecFlags *n = G_PARAM_SPEC_FLAGS (new);

    if (c->default_value != n->default_value ||

        cur->value_type != new->value_type) {

      GRL_DEBUG ("%s differ (values: %d and %d) (types: %s and %s)",

                 g_type_name (ctype), c->default_value, n->default_value,

                 g_type_name (cur->value_type), g_type_name (new->value_type));

      return FALSE;

    }

  } else if (ctype == G_TYPE_PARAM_BOOLEAN) {

    GParamSpecBoolean *c = G_PARAM_SPEC_BOOLEAN (cur);

    GParamSpecBoolean *n = G_PARAM_SPEC_BOOLEAN (new);

    if (c->default_value != n->default_value) {

      GRL_DEBUG ("%s type differ: %s != %s", g_type_name (ctype),

                 g_type_name (cur->value_type), g_type_name (new->value_type));

      return FALSE;

    }

  } else if (ctype == G_TYPE_PARAM_BOXED || ctype == G_TYPE_PARAM_OBJECT) {

    if (cur->value_type != new->value_type) {

      GRL_DEBUG ("%s type differ: %s != %s", g_type_name (ctype),

                 g_type_name (cur->value_type), g_type_name (new->value_type));

      return FALSE;

    }

  } else {

    g_warn_if_reached();

    return FALSE;

  }

  return TRUE;

}

#undef CHECK_NUMERIC_PARAM_SPEC_LIMITS

static void

shutdown_plugin (GrlPlugin *plugin)

{

  GRL_DEBUG ("Unloading plugin '%s'", grl_plugin_get_id (plugin));

  grl_plugin_unload (plugin);

  if (grl_plugin_get_module (plugin)) {

    g_module_close (grl_plugin_get_module (plugin));

    grl_plugin_set_module (plugin, NULL);

  }

}

/* ================ PRIVATE API ================ */

/*

 * grl_registry_restrict_plugins:

 * @registry: the registry instance

 * @plugins: a @NULL-terminated array of plugins identifiers

 *

 * Restrict the plugins that application sees to this list.

 *

 * Other plugins will not be available for the application, unless it uses

 * directly #grl_registry_load_plugin() function.

 **/

void

grl_registry_restrict_plugins (GrlRegistry *registry,

                               gchar **plugins)

{

  g_return_if_fail (GRL_IS_REGISTRY (registry));

  g_return_if_fail (plugins);

  /* Free previous list */

  if (registry->priv->allowed_plugins) {

    g_slist_free_full (registry->priv->allowed_plugins, g_free);

    registry->priv->allowed_plugins = NULL;

  }

  while (*plugins) {

    registry->priv->allowed_plugins = g_slist_prepend (registry->priv->allowed_plugins,

                                                       g_strdup (*plugins));

    plugins++;

  }

}

/*

 * grl_registry_shutdown:

 * @registry: the registry instance

 *

 * Frees all the resources in the registry and the registry itself.

 **/

void

grl_registry_shutdown (GrlRegistry *registry)

{

  GHashTableIter iter;

  GList *each_key;