/* This file is part of GEGL

 *

 * 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 3 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 GEGL; if not, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <string.h>

#include <glib-object.h>

#include "gegl-plugin.h"

#include "geglmodule.h"

#include "geglmoduledb.h"

#include "gegldatafiles.h"

enum

{

  ADD,

  REMOVE,

  MODULE_MODIFIED,

  LAST_SIGNAL

};

/*  #define DUMP_DB 1  */

static void         gegl_module_db_finalize            (GObject      *object);

static void         gegl_module_db_module_initialize   (const GeglDatafileData *file_data,

                                                        gpointer                user_data);

static GeglModule * gegl_module_db_module_find_by_path (GeglModuleDB *db,

                                                        const char   *fullpath);

#ifdef DUMP_DB

static void         gegl_module_db_dump_module         (gpointer      data,

                                                        gpointer      user_data);

#endif

static void         gegl_module_db_module_on_disk_func (gpointer      data,

                                                        gpointer      user_data);

static void         gegl_module_db_module_remove_func  (gpointer      data,

                                                        gpointer      user_data);

static void         gegl_module_db_module_modified     (GeglModule   *module,

                                                        GeglModuleDB *db);

G_DEFINE_TYPE (GeglModuleDB, gegl_module_db, G_TYPE_OBJECT)

#define parent_class gegl_module_db_parent_class

static guint db_signals[LAST_SIGNAL] = { 0 };

static void

gegl_module_db_class_init (GeglModuleDBClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  db_signals[ADD] =

    g_signal_new ("add",

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_FIRST,

                  G_STRUCT_OFFSET (GeglModuleDBClass, add),

                  NULL, NULL,

                  g_cclosure_marshal_VOID__OBJECT,

                  G_TYPE_NONE, 1,

                  GEGL_TYPE_MODULE);

  db_signals[REMOVE] =

    g_signal_new ("remove",

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_FIRST,

                  G_STRUCT_OFFSET (GeglModuleDBClass, remove),

                  NULL, NULL,

                  g_cclosure_marshal_VOID__OBJECT,

                  G_TYPE_NONE, 1,

                  GEGL_TYPE_MODULE);

  db_signals[MODULE_MODIFIED] =

    g_signal_new ("module-modified",

                  G_TYPE_FROM_CLASS (klass),

                  G_SIGNAL_RUN_FIRST,

                  G_STRUCT_OFFSET (GeglModuleDBClass, module_modified),

                  NULL, NULL,

                  g_cclosure_marshal_VOID__OBJECT,

                  G_TYPE_NONE, 1,

                  GEGL_TYPE_MODULE);

  object_class->finalize = gegl_module_db_finalize;

  klass->add             = NULL;

  klass->remove          = NULL;

}

static void

gegl_module_db_init (GeglModuleDB *db)

{

  db->modules      = NULL;

  db->load_inhibit = NULL;

  db->verbose      = FALSE;

}

static void

gegl_module_db_finalize (GObject *object)

{

  GeglModuleDB *db = GEGL_MODULE_DB (object);

  if (db->modules)

    {

      g_list_free (db->modules);

      db->modules = NULL;

    }

  if (db->load_inhibit)

    {

      g_free (db->load_inhibit);

      db->load_inhibit = NULL;

    }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

/**

 * gegl_module_db_new:

 * @verbose: Pass %TRUE to enable debugging output.

 *

 * Creates a new #GeglModuleDB instance. The @verbose parameter will be

 * passed to the created #GeglModule instances using gegl_module_new().

 *

 * Return value: The new #GeglModuleDB instance.

 **/

GeglModuleDB *

gegl_module_db_new (gboolean verbose)

{

  GeglModuleDB *db;

  db = g_object_new (GEGL_TYPE_MODULE_DB, NULL);

  db->verbose = verbose ? TRUE : FALSE;

  return db;

}

static gboolean

is_in_inhibit_list (const gchar *filename,

                    const gchar *inhibit_list)

{

  gchar       *p;

  gint         pathlen;

  const gchar *start;

  const gchar *end;

  if (! inhibit_list || ! strlen (inhibit_list))

    return FALSE;

  p = strstr (inhibit_list, filename);

  if (!p)

    return FALSE;

  /* we have a substring, but check for colons either side */

  start = p;

  while (start != inhibit_list && *start != G_SEARCHPATH_SEPARATOR)

    start--;

  if (*start == G_SEARCHPATH_SEPARATOR)

    start++;

  end = strchr (p, G_SEARCHPATH_SEPARATOR);

  if (! end)

    end = inhibit_list + strlen (inhibit_list);

  pathlen = strlen (filename);

  if ((end - start) == pathlen)

    return TRUE;

  return FALSE;

}

/**

 * gegl_module_db_set_load_inhibit:

 * @db:           A #GeglModuleDB.

 * @load_inhibit: A #G_SEARCHPATH_SEPARATOR delimited list of module

 *                filenames to exclude from auto-loading.

 *

 * Sets the @load_inhibit flag for all #GeglModule's which are kept

 * by @db (using gegl_module_set_load_inhibit()).

 **/

void

gegl_module_db_set_load_inhibit (GeglModuleDB *db,

                                 const gchar  *load_inhibit)

{

  GList *list;

  g_return_if_fail (GEGL_IS_MODULE_DB (db));

  if (db->load_inhibit)

    g_free (db->load_inhibit);

  db->load_inhibit = g_strdup (load_inhibit);

  for (list = db->modules; list; list = g_list_next (list))

    {

      GeglModule *module = list->data;

      gegl_module_set_load_inhibit (module,

                                    is_in_inhibit_list (module->filename,

                                                        load_inhibit));

    }

}

/**

 * gegl_module_db_get_load_inhibit:

 * @db: A #GeglModuleDB.

 *

 * Return the #G_SEARCHPATH_SEPARATOR selimited list of module filenames

 * which are excluded from auto-loading.

 *

 * Return value: the @db's @load_inhibit string.

 **/

const gchar *

gegl_module_db_get_load_inhibit (GeglModuleDB *db)

{

  g_return_val_if_fail (GEGL_IS_MODULE_DB (db), NULL);

  return db->load_inhibit;

}

/**

 * gegl_module_db_load:

 * @db:          A #GeglModuleDB.

 * @module_path: A #G_SEARCHPATH_SEPARATOR delimited list of directories

 *               to load modules from.

 *

 * Scans the directories contained in @module_path using

 * gegl_datafiles_read_directories() and creates a #GeglModule

 * instance for every loadable module contained in the directories.

 **/

void

gegl_module_db_load (GeglModuleDB *db,

                     const gchar  *module_path)

{

  g_return_if_fail (GEGL_IS_MODULE_DB (db));

  g_return_if_fail (module_path != NULL);

  if (g_module_supported ())

    gegl_datafiles_read_directories (module_path,

                                     G_FILE_TEST_EXISTS,

                                     gegl_module_db_module_initialize,

                                     db);

#ifdef DUMP_DB

  g_list_foreach (db->modules, gegl_module_db_dump_module, NULL);

#endif

}

/**

 * gegl_module_db_refresh:

 * @db:          A #GeglModuleDB.

 * @module_path: A #G_SEARCHPATH_SEPARATOR delimited list of directories

 *               to load modules from.

 *

 * Does the same as gegl_module_db_load(), plus removes all #GeglModule

 * instances whose modules have been deleted from disk.

 *

 * Note that the #GeglModule's will just be removed from the internal

 * list and not freed as this is not possible with #GTypeModule

 * instances which actually implement types.

 **/

void

gegl_module_db_refresh (GeglModuleDB *db,

                        const gchar  *module_path)

{

  GList *kill_list = NULL;

  g_return_if_fail (GEGL_IS_MODULE_DB (db));

  g_return_if_fail (module_path != NULL);

  /* remove modules we don't have on disk anymore */

  g_list_foreach (db->modules,

                  gegl_module_db_module_on_disk_func,

                  &kill_list);

  g_list_foreach (kill_list,

                  gegl_module_db_module_remove_func,

                  db);

  g_list_free (kill_list);

  /* walk filesystem and add new things we find */

  gegl_datafiles_read_directories (module_path,

                                   G_FILE_TEST_EXISTS,

                                   gegl_module_db_module_initialize,

                                   db);

}

/* name must be of the form lib*.so (Unix) or *.dll (Win32) */

static gboolean

valid_module_name (const gchar *filename)

{

  gchar *basename = g_path_get_basename (filename);

  if (! gegl_datafiles_check_extension (basename, "." G_MODULE_SUFFIX))

    {

      g_free (basename);

      return FALSE;

    }

  g_free (basename);

  return TRUE;

}

static void

gegl_module_db_module_initialize (const GeglDatafileData *file_data,

                                  gpointer                user_data)

{

  GeglModuleDB *db = GEGL_MODULE_DB (user_data);

  GeglModule   *module;

  gboolean      load_inhibit;

  if (! valid_module_name (file_data->filename))

    return;

  /* don't load if we already know about it */

  if (gegl_module_db_module_find_by_path (db, file_data->filename))

    return;

  load_inhibit = is_in_inhibit_list (file_data->filename,

                                     db->load_inhibit);

  module = gegl_module_new (file_data->filename,

                            load_inhibit,

                            db->verbose);

  g_signal_connect (module, "modified",

                    G_CALLBACK (gegl_module_db_module_modified),

                    db);

  db->modules = g_list_append (db->modules, module);

  g_signal_emit (db, db_signals[ADD], 0, module);

}

static GeglModule *

gegl_module_db_module_find_by_path (GeglModuleDB *db,

                                    const char   *fullpath)

{

  GList *list;

  for (list = db->modules; list; list = g_list_next (list))

    {

      GeglModule *module = list->data;

      if (! strcmp (module->filename, fullpath))

        return module;

    }

  return NULL;

}

#ifdef DUMP_DB

static void

gegl_module_db_dump_module (gpointer data,

                            gpointer user_data)

{

  GeglModule *module = data;

  g_print ("\n%s: %s\n",

           module->filename,

           gegl_module_state_name (module->state));

  g_print ("  module: %p  lasterr: %s  query: %p register: %p\n",

           module->module,

           module->last_module_error ? module->last_module_error : "NONE",

           module->query_module,

           module->register_module);

}

#endif

static void

gegl_module_db_module_on_disk_func (gpointer data,

                                    gpointer user_data)

{

  GeglModule  *module    = data;

  GList      **kill_list = user_data;

  gboolean     old_on_disk;

  old_on_disk = module->on_disk;

  module->on_disk = g_file_test (module->filename, G_FILE_TEST_IS_REGULAR);

  /* if it's not on the disk, and it isn't in memory, mark it to be

   * removed later.

   */

  if (! module->on_disk && ! module->module)

    {

      *kill_list = g_list_append (*kill_list, module);

      module = NULL;

    }

  if (module && module->on_disk != old_on_disk)

    gegl_module_modified (module);

}

static void

gegl_module_db_module_remove_func (gpointer data,

                                   gpointer user_data)

{

  GeglModule   *module = data;

  GeglModuleDB *db     = user_data;

  g_signal_handlers_disconnect_by_func (module,

                                        gegl_module_db_module_modified,

                                        db);

  db->modules = g_list_remove (db->modules, module);

  g_signal_emit (db, db_signals[REMOVE], 0, module);

}

static void

gegl_module_db_module_modified (GeglModule   *module,

                                GeglModuleDB *db)

{

  g_signal_emit (db, db_signals[MODULE_MODIFIED], 0, module);

}