/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */

/* vim:set et sts=4: */

/* bus - The Input Bus

 * Copyright (C) 2015 Peng Huang <shawn.p.huang@gmail.com>

 * Copyright (C) 2015-2018 Takao Fujiwara <takao.fujiwara1@gmail.com>

 * Copyright (C) 2015 Red Hat, Inc.

 *

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

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301

 * USA

 */

#include <gio/gio.h>

#include <glib/gstdio.h>

#include <string.h>

#include "ibusinternal.h"

#include "ibusmarshalers.h"

#include "ibusregistry.h"

#define IBUS_CACHE_MAGIC 0x49425553 /* "IBUS" */

#define IBUS_CACHE_VERSION 0x00010512

enum {

    CHANGED,

    LAST_SIGNAL,

};

static guint             _signals[LAST_SIGNAL] = { 0 };

struct _IBusRegistryPrivate {

    /* a list of IBusObservedPath objects. */

    GList *observed_paths;

    /* a list of IBusComponent objects that are created from component XML

     * files (or from the cache of them). */

    GList *components;

    gboolean changed;

    /* a mapping from GFile to GFileMonitor. */

    GHashTable *monitor_table;

    guint monitor_timeout_id;

};

#define IBUS_REGISTRY_GET_PRIVATE(o)  \

   (G_TYPE_INSTANCE_GET_PRIVATE ((o), IBUS_TYPE_REGISTRY, IBusRegistryPrivate))

/* functions prototype */

static void     ibus_registry_destroy        (IBusRegistry           *registry);

static void     ibus_registry_remove_all     (IBusRegistry           *registry);

static gboolean ibus_registry_serialize      (IBusRegistry           *registry,

                                              GVariantBuilder        *builder);

static gint     ibus_registry_deserialize    (IBusRegistry           *registry,

                                              GVariant               *variant);

static gboolean ibus_registry_copy           (IBusRegistry           *dest,

                                              const IBusRegistry     *src);

G_DEFINE_TYPE (IBusRegistry, ibus_registry, IBUS_TYPE_SERIALIZABLE)

static void

ibus_registry_class_init (IBusRegistryClass *class)

{

    GObjectClass *gobject_class = G_OBJECT_CLASS (class);

    IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (class);

    IBusSerializableClass *serializable_class = IBUS_SERIALIZABLE_CLASS (class);

    ibus_object_class->destroy = (IBusObjectDestroyFunc) ibus_registry_destroy;

    serializable_class->serialize =

        (IBusSerializableSerializeFunc) ibus_registry_serialize;

    serializable_class->deserialize =

        (IBusSerializableDeserializeFunc) ibus_registry_deserialize;

    serializable_class->copy = (IBusSerializableCopyFunc) ibus_registry_copy;

    g_type_class_add_private (class, sizeof (IBusRegistryPrivate));

    /* install signals */

    /**

     * IBusRegistry::changed:

     * @registry: An #IBusRegistry.

     *

     * Emitted when any observed paths are changed.

     * A method is not associated in this class. the "changed"

     * signal would be handled in other classes.

     *

     * See also: ibus_registry_start_monitor_changes().

     */

    _signals[CHANGED] =

        g_signal_new (I_("changed"),

            G_TYPE_FROM_CLASS (gobject_class),

            G_SIGNAL_RUN_LAST,

            0,

            NULL, NULL,

            _ibus_marshal_VOID__VOID,

            G_TYPE_NONE,

            0);

}

static void

ibus_registry_init (IBusRegistry *registry)

{

    registry->priv = IBUS_REGISTRY_GET_PRIVATE (registry);

    registry->priv->observed_paths = NULL;

    registry->priv->components = NULL;

    registry->priv->changed = FALSE;

    registry->priv->monitor_table =

        g_hash_table_new_full (g_file_hash,

                               (GEqualFunc) g_file_equal,

                               (GDestroyNotify) g_object_unref,

                               (GDestroyNotify) g_object_unref);

}

static void

ibus_registry_destroy (IBusRegistry *registry)

{

    ibus_registry_remove_all (registry);

    g_hash_table_destroy (registry->priv->monitor_table);

    registry->priv->monitor_table = NULL;

    if (registry->priv->monitor_timeout_id > 0) {

        g_source_remove (registry->priv->monitor_timeout_id);

        registry->priv->monitor_timeout_id = 0;

    }

    IBUS_OBJECT_CLASS (ibus_registry_parent_class)->

            destroy (IBUS_OBJECT (registry));

}

static gboolean

ibus_registry_serialize (IBusRegistry    *registry,

                         GVariantBuilder *builder)

{

    gboolean retval;

    retval = IBUS_SERIALIZABLE_CLASS (ibus_registry_parent_class)->

        serialize ((IBusSerializable *)registry, builder);

    g_return_val_if_fail (retval, FALSE);

    GList *p;

    GVariantBuilder *array;

    array = g_variant_builder_new (G_VARIANT_TYPE ("av"));

    for (p = registry->priv->observed_paths; p != NULL; p = p->next) {

        IBusSerializable *serializable = (IBusSerializable *) p->data;

        g_variant_builder_add (array,

                               "v",

                               ibus_serializable_serialize (serializable));

    }

    g_variant_builder_add (builder, "av", array);

    g_variant_builder_unref (array);

    array = g_variant_builder_new (G_VARIANT_TYPE ("av"));

    for (p = registry->priv->components; p != NULL; p = p->next) {

        IBusSerializable *serializable = (IBusSerializable *) p->data;

        g_variant_builder_add (array,

                               "v",

                               ibus_serializable_serialize (serializable));

    }

    g_variant_builder_add (builder, "av", array);

    g_variant_builder_unref (array);

    return TRUE;

}

static gint

ibus_registry_deserialize (IBusRegistry *registry,

                           GVariant     *variant)

{

    GVariant *var;

    GVariantIter *iter;

    gint retval;

    retval = IBUS_SERIALIZABLE_CLASS (ibus_registry_parent_class)->

        deserialize ((IBusSerializable *)registry, variant);

    g_return_val_if_fail (retval, 0);

    g_variant_get_child (variant, retval++, "av", &iter);

    while (g_variant_iter_loop (iter, "v", &var)) {

        IBusSerializable *serializable = ibus_serializable_deserialize (var);

        registry->priv->observed_paths =

            g_list_append (registry->priv->observed_paths,

                           IBUS_OBSERVED_PATH (serializable));

    }

    g_variant_iter_free (iter);

    g_variant_get_child (variant, retval++, "av", &iter);

    while (g_variant_iter_loop (iter, "v", &var)) {

        IBusSerializable *serializable = ibus_serializable_deserialize (var);

        registry->priv->components =

            g_list_append (registry->priv->components,

                           IBUS_COMPONENT (serializable));

    }

    g_variant_iter_free (iter);

    return retval;

}

static gboolean

ibus_registry_copy (IBusRegistry       *dest,

                    const IBusRegistry *src)

{

    gboolean retval;

    retval = IBUS_SERIALIZABLE_CLASS (ibus_registry_parent_class)->

        copy ((IBusSerializable *)dest, (IBusSerializable *)src);

    g_return_val_if_fail (retval, FALSE);

    dest->priv->components = g_list_copy (src->priv->components);

    dest->priv->observed_paths = g_list_copy (src->priv->observed_paths);

    return TRUE;

}

/**

 * ibus_registry_remove_all:

 *

 * Remove the loaded registry.

 */

static void

ibus_registry_remove_all (IBusRegistry *registry)

{

    g_assert (IBUS_IS_REGISTRY (registry));

    g_list_free_full (registry->priv->observed_paths, g_object_unref);

    registry->priv->observed_paths = NULL;

    g_list_free_full (registry->priv->components, g_object_unref);

    registry->priv->components = NULL;

}

void

ibus_registry_load (IBusRegistry *registry)

{

    const gchar *envstr;

    GPtrArray *path;

    gchar **d, **search_path;

    g_assert (IBUS_IS_REGISTRY (registry));

    path = g_ptr_array_new();

    envstr = g_getenv ("IBUS_COMPONENT_PATH");

    if (envstr) {

        gchar **dirs = g_strsplit (envstr, G_SEARCHPATH_SEPARATOR_S, 0);

        for (d = dirs; *d != NULL; d++)

            g_ptr_array_add (path, *d);

        g_free (dirs);

    } else {

        gchar *dirname;

        dirname = g_build_filename (IBUS_DATA_DIR, "component", NULL);

        g_ptr_array_add (path, dirname);

#if 0

        /* FIXME Should we support install some IME in user dir? */

        dirname = g_build_filename (g_get_user_data_dir (),

                                    "ibus", "component",

                                    NULL);

        g_ptr_array_add (path, dirname);

#endif

    }

    g_ptr_array_add (path, NULL);

    search_path = (gchar **) g_ptr_array_free (path, FALSE);

    for (d = search_path; *d != NULL; d++) {

        ibus_registry_load_in_dir (registry, *d);

    }

    g_strfreev (search_path);

}

gboolean

ibus_registry_load_cache (IBusRegistry *registry,

                          gboolean      is_user)

{

    gchar *filename;

    gboolean retval;

    g_assert (IBUS_IS_REGISTRY (registry));

    if (is_user) {

        filename = g_build_filename (g_get_user_cache_dir (),

                                     "ibus", "bus", "registry", NULL);

    } else {

        filename = g_build_filename (IBUS_CACHE_DIR,

                                     "bus", "registry", NULL);

    }

    retval = ibus_registry_load_cache_file (registry, filename);

    g_free (filename);

    return retval;

}

gboolean

ibus_registry_load_cache_file (IBusRegistry *registry,

                               const gchar  *filename)

{

    gchar *contents, *p;

    gsize length;

    GVariant *variant;

    GError *error;

    g_assert (IBUS_IS_REGISTRY (registry));

    g_assert (filename != NULL);

    if (!g_file_test (filename, G_FILE_TEST_EXISTS))

        return FALSE;

    error = NULL;

    if (!g_file_get_contents (filename, &contents, &length, &error)) {

        g_warning ("cannot read %s: %s", filename, error->message);

        g_error_free (error);

        return FALSE;

    }

    p = contents;

    /* read file header including magic and version */

    if (length < 8) {

        g_free (contents);

        return FALSE;

    }

    if (GUINT32_FROM_BE (*(guint32 *) p) != IBUS_CACHE_MAGIC) {

        g_free (contents);

        return FALSE;

    }

    p += 4;

    if (GUINT32_FROM_BE (*(guint32 *) p) != IBUS_CACHE_VERSION) {

        g_free (contents);

        return FALSE;

    }

    p += 4;

    /* read serialized IBusRegistry */

    variant = g_variant_new_from_data (G_VARIANT_TYPE ("(sa{sv}avav)"),

                                       p,

                                       length - (p - contents),

                                       FALSE,

                                       (GDestroyNotify) g_free,

                                       NULL);

    if (variant == NULL) {

        g_free (contents);

        return FALSE;

    }

    ibus_registry_deserialize (registry, variant);

    g_variant_unref (variant);

    g_free (contents);

    return TRUE;

}

gboolean

ibus_registry_check_modification (IBusRegistry *registry)

{

    GList *p;

    g_assert (IBUS_IS_REGISTRY (registry));

    for (p = registry->priv->observed_paths; p != NULL; p = p->next) {

        if (!IBUS_IS_OBSERVED_PATH (p->data)) {

            g_warning ("The registry cache of observed_paths might be " \

                       "broken and have to generate the cache again.");

            g_list_free_full (registry->priv->observed_paths, g_object_unref);

            registry->priv->observed_paths = NULL;

            return TRUE;

        }

        if (ibus_observed_path_check_modification (

                    (IBusObservedPath *) p->data))

            return TRUE;

    }

    for (p = registry->priv->components; p != NULL; p = p->next) {

        if (!IBUS_IS_COMPONENT (p->data)) {

            g_warning ("The registry cache of components might be " \

                       "broken and have to generate the cache again.");

            g_list_free_full (registry->priv->components, g_object_unref);

            registry->priv->components = NULL;

            return TRUE;

        }

        if (ibus_component_check_modification ((IBusComponent *) p->data))

            return TRUE;

    }

    return FALSE;

}

gboolean

ibus_registry_save_cache (IBusRegistry *registry,

                          gboolean      is_user)

{

    gchar *filename;

    gboolean retval;

    g_assert (IBUS_IS_REGISTRY (registry));

    if (is_user) {

        filename = g_build_filename (g_get_user_cache_dir (),

                                     "ibus", "bus", "registry", NULL);

    } else {

        filename = g_build_filename (IBUS_CACHE_DIR,

                                     "bus", "registry", NULL);

    }

    retval = ibus_registry_save_cache_file (registry, filename);

    g_free (filename);

    return retval;

}

gboolean

ibus_registry_save_cache_file (IBusRegistry *registry,

                               const gchar  *filename)

{

    gchar *cachedir;

    GVariant *variant;

    gchar *contents, *p;

    gsize length;

    gboolean retval;

    guint32 intval;

    GError *error;

    g_assert (IBUS_IS_REGISTRY (registry));

    g_assert (filename != NULL);

    cachedir = g_path_get_dirname (filename);

    g_mkdir_with_parents (cachedir, 0775);

    g_free (cachedir);

    variant = ibus_serializable_serialize (IBUS_SERIALIZABLE (registry));

    length = 8 + g_variant_get_size (variant);

    p = contents = g_slice_alloc (length);

    /* write file header */

    intval = GUINT32_TO_BE (IBUS_CACHE_MAGIC);

    memcpy (p, (gchar *) &intval, 4);

    p += 4;

    intval = GUINT32_TO_BE (IBUS_CACHE_VERSION);

    memcpy (p, (gchar *) &intval, 4);

    p += 4;

    /* write serialized IBusRegistry */

    g_variant_store (variant, p);

    error = NULL;

    retval = g_file_set_contents (filename, contents, length, &error);

    g_variant_unref (variant);

    g_slice_free1 (length, contents);

    if (!retval) {

        g_warning ("cannot write %s: %s", filename, error->message);

        g_error_free (error);

        return FALSE;

    }

    if (g_str_has_prefix (filename, g_get_user_cache_dir ())) {

        g_warn_if_fail (!g_chmod (filename, 0644));

    }

    return TRUE;

}

#define g_string_append_indent(string, indent)  \

    {                                           \

        gint i;                                 \

        for (i = 0; i < (indent); i++) {        \

            g_string_append (string, "    ");   \

        }                                       \

    }

void

ibus_registry_output (IBusRegistry *registry,

                      GString      *output,

                      int           indent)

{

    GList *p;

    g_assert (IBUS_IS_REGISTRY (registry));

    g_return_if_fail (output != NULL);

    g_string_append (output, "\n");

    g_string_append (output, "<ibus-registry>\n");

    if (registry->priv->observed_paths) {

        g_string_append_indent (output, indent);

        g_string_append (output, "<observed-paths>\n");

        for (p = registry->priv->observed_paths; p != NULL; p = p->next) {

            ibus_observed_path_output ((IBusObservedPath *) p->data,

                                      output, indent * 2);

        }

        g_string_append_indent (output, indent);

        g_string_append (output, "</observed-paths>\n");

    }

    if (registry->priv->components) {

        g_string_append_indent (output, indent);

        g_string_append (output, "<components>\n");

        for (p = registry->priv->components; p != NULL; p = p->next) {

            ibus_component_output ((IBusComponent *) p->data,

                                   output, indent * 2);

        }

        g_string_append_indent (output, indent);

        g_string_append (output, "</components>\n");

    }

    g_string_append (output, "</ibus-registry>\n");

}

void

ibus_registry_load_in_dir (IBusRegistry *registry,

                           const gchar  *dirname)

{

    GError *error = NULL;

    GDir *dir;

    IBusObservedPath *observed_path = NULL;

    const gchar *filename;

    g_assert (IBUS_IS_REGISTRY (registry));

    g_assert (dirname);

    dir = g_dir_open (dirname, 0, &error);

    if (dir == NULL) {

        g_warning ("Unable open directory %s : %s", dirname, error->message);

        g_error_free (error);

        return;

    }

    observed_path = ibus_observed_path_new (dirname, TRUE);

    registry->priv->observed_paths =

            g_list_append (registry->priv->observed_paths,

                           observed_path);

    while ((filename = g_dir_read_name (dir)) != NULL) {

        glong size;

        gchar *path;

        IBusComponent *component;

        size = g_utf8_strlen (filename, -1);

        if (g_strcmp0 (MAX (filename, filename + size - 4), ".xml") != 0)

            continue;

        path = g_build_filename (dirname, filename, NULL);

        component = ibus_component_new_from_file (path);

        if (component != NULL) {

            g_object_ref_sink (component);

            registry->priv->components =

                g_list_append (registry->priv->components, component);

        }

        g_free (path);

    }

    g_dir_close (dir);

}

IBusRegistry *

ibus_registry_new (void)

{

    IBusRegistry *registry;

    registry = (IBusRegistry *) g_object_new (IBUS_TYPE_REGISTRY, NULL);

    return registry;

}

GList *

ibus_registry_get_components (IBusRegistry *registry)

{

    g_assert (IBUS_IS_REGISTRY (registry));

    return g_list_copy (registry->priv->components);

}

GList *

ibus_registry_get_observed_paths (IBusRegistry *registry)

{

    g_assert (IBUS_IS_REGISTRY (registry));

    return g_list_copy (registry->priv->observed_paths);

}

static gboolean

_monitor_timeout_cb (IBusRegistry *registry)

{

    g_hash_table_remove_all (registry->priv->monitor_table);

    registry->priv->changed = TRUE;

    g_signal_emit (registry, _signals[CHANGED], 0);

    registry->priv->monitor_timeout_id = 0;

    return FALSE;

}

static void

_monitor_changed_cb (GFileMonitor     *monitor,

                     GFile            *file,

                     GFile            *other_file,

                     GFileMonitorEvent event_type,

                     IBusRegistry     *registry)

{

    g_assert (IBUS_IS_REGISTRY (registry));

    if (event_type != G_FILE_MONITOR_EVENT_CHANGED &&

        event_type != G_FILE_MONITOR_EVENT_DELETED &&

        event_type != G_FILE_MONITOR_EVENT_CREATED &&

        event_type != G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED)

        return;

    /* Merge successive file changes into one, with a low priority

       timeout handler. */

    if (registry->priv->monitor_timeout_id > 0)

        return;

    registry->priv->monitor_timeout_id =

        g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,

                            5000,

                            (GSourceFunc) _monitor_timeout_cb,

                            g_object_ref (registry),

                            (GDestroyNotify) g_object_unref);

}

void

ibus_registry_start_monitor_changes (IBusRegistry *registry)

{

    GList *observed_paths, *p;

    g_assert (IBUS_IS_REGISTRY (registry));

    g_hash_table_remove_all (registry->priv->monitor_table);

    observed_paths = g_list_copy (registry->priv->observed_paths);

    for (p = registry->priv->components; p != NULL; p = p->next) {

        IBusComponent *component = (IBusComponent *) p->data;

        GList *component_observed_paths =

            ibus_component_get_observed_paths (component);

        observed_paths = g_list_concat (observed_paths,

                                        component_observed_paths);

    }

    for (p = observed_paths; p != NULL; p = p->next) {

        IBusObservedPath *path = (IBusObservedPath *) p->data;

        GFile *file = g_file_new_for_path (path->path);

        if (g_hash_table_lookup (registry->priv->monitor_table, file) == NULL) {

            GFileMonitor *monitor;

            GError *error;

            error = NULL;

            monitor = g_file_monitor (file,

                                      G_FILE_MONITOR_NONE,

                                      NULL,

                                      &error);

            if (monitor != NULL) {

                g_signal_connect (monitor, "changed",

                                  G_CALLBACK (_monitor_changed_cb),

                                  registry);

                g_hash_table_replace (registry->priv->monitor_table,

                                      g_object_ref (file),

                                      monitor);

            } else {

                g_warning ("Can't monitor directory %s: %s",

                           path->path,

                           error->message);

                g_error_free (error);

            }

        }

        g_object_unref (file);

    }

    g_list_free (observed_paths);

}