/*

 * GNOME Online Miners - crawls through your online content

 * Copyright (C) 2014 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

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

 * 02110-1301, USA.

 *

 * Author: Debarshi Ray <debarshir@gnome.org>

 *

 */

#include "config.h"

#include "gom-application.h"

#include "gom-dbus.h"

#include "gom-miner.h"

#define AUTOQUIT_TIMEOUT 5 /* seconds */

struct _GomApplication

{

  GApplication parent;

  GCancellable *cancellable;

  GomDBus *skeleton;

  GomMiner *miner;

  GQueue *queue;

  GType miner_type;

  gboolean refreshing;

};

struct _GomApplicationClass

{

  GApplicationClass parent_class;

};

enum

{

  PROP_0,

  PROP_MINER_TYPE

};

G_DEFINE_TYPE (GomApplication, gom_application, G_TYPE_APPLICATION);

static void gom_application_refresh_db_cb (GObject *source, GAsyncResult *res, gpointer user_data);

static void

gom_application_insert_shared_content_cb (GObject *source,

                                          GAsyncResult *res,

                                          gpointer user_data)

{

  GomApplication *self;

  GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data);

  GError *error;

  self = GOM_APPLICATION (g_application_get_default ());

  g_application_release (G_APPLICATION (self));

  error = NULL;

  if (!gom_miner_insert_shared_content_finish (GOM_MINER (source), res, &error))

    {

      g_printerr ("Failed to insert shared content: %s\n", error->message);

      g_dbus_method_invocation_take_error (invocation, error);

      goto out;

    }

  gom_dbus_complete_insert_shared_content (self->skeleton, invocation);

 out:

  g_object_unref (invocation);

}

static gboolean

gom_application_insert_shared_content (GomApplication *self,

                                       GDBusMethodInvocation *invocation,

                                       const gchar *account_id,

                                       const gchar *shared_id,

                                       const gchar *shared_type,

                                       const gchar *source_urn)

{

  g_application_hold (G_APPLICATION (self));

  gom_miner_insert_shared_content_async (self->miner,

                                         account_id,

                                         shared_id,

                                         shared_type,

                                         source_urn,

                                         self->cancellable,

                                         gom_application_insert_shared_content_cb,

                                         g_object_ref (invocation));

  return TRUE;

}

static void

gom_application_process_queue (GomApplication *self)

{

  GDBusMethodInvocation *invocation = NULL;

  const gchar **index_types;

  if (self->refreshing)

    goto out;

  if (g_queue_is_empty (self->queue))

    goto out;

  invocation = G_DBUS_METHOD_INVOCATION (g_queue_pop_head (self->queue));

  index_types = g_object_get_data (G_OBJECT (invocation), "index-types");

  gom_miner_set_index_types (self->miner, index_types);

  self->refreshing = TRUE;

  g_application_hold (G_APPLICATION (self));

  gom_miner_refresh_db_async (self->miner,

                              self->cancellable,

                              gom_application_refresh_db_cb,

                              g_object_ref (invocation));

 out:

  g_clear_object (&invocation);

}

static void

gom_application_refresh_db_cb (GObject *source,

                               GAsyncResult *res,

                               gpointer user_data)

{

  GomApplication *self;

  GDBusMethodInvocation *invocation = user_data;

  GError *error = NULL;

  self = GOM_APPLICATION (g_application_get_default ());

  g_application_release (G_APPLICATION (self));

  self->refreshing = FALSE;

  gom_miner_refresh_db_finish (GOM_MINER (source), res, &error);

  if (error != NULL)

    {

      g_printerr ("Failed to refresh the DB cache: %s\n", error->message);

      g_dbus_method_invocation_take_error (invocation, error);

      goto out;

    }

  gom_dbus_complete_refresh_db (self->skeleton, invocation);

 out:

  g_object_unref (invocation);

  gom_application_process_queue (self);

}

static gboolean

gom_application_refresh_db (GomApplication *self,

                            GDBusMethodInvocation *invocation,

                            const gchar *const *arg_index_types)

{

  gchar **index_types;

  index_types = g_strdupv ((gchar **) arg_index_types);

  g_object_set_data_full (G_OBJECT (invocation), "index-types", index_types, (GDestroyNotify) g_strfreev);

  g_queue_push_tail (self->queue, g_object_ref (invocation));

  gom_application_process_queue (self);

  return TRUE;

}

static gboolean

gom_application_dbus_register (GApplication *application,

                               GDBusConnection *connection,

                               const gchar *object_path,

                               GError **error)

{

  GomApplication *self = GOM_APPLICATION (application);

  gboolean retval = FALSE;

  if (!G_APPLICATION_CLASS (gom_application_parent_class)->dbus_register (application,

                                                                          connection,

                                                                          object_path,

                                                                          error))

    goto out;

  if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (self->skeleton),

                                         connection,

                                         object_path,

                                         error))

    goto out;

  retval = TRUE;

 out:

  return retval;

}

static void

gom_application_dbus_unregister (GApplication *application,

                                 GDBusConnection *connection,

                                 const gchar *object_path)

{

  GomApplication *self = GOM_APPLICATION (application);

  if (self->skeleton != NULL)

    {

      if (g_dbus_interface_skeleton_has_connection (G_DBUS_INTERFACE_SKELETON (self->skeleton), connection))

        g_dbus_interface_skeleton_unexport_from_connection (G_DBUS_INTERFACE_SKELETON (self->skeleton),

                                                            connection);

    }

  G_APPLICATION_CLASS (gom_application_parent_class)->dbus_unregister (application, connection, object_path);

}

static void

gom_application_shutdown (GApplication *application)

{

  GomApplication *self = GOM_APPLICATION (application);

  g_cancellable_cancel (self->cancellable);

  G_APPLICATION_CLASS (gom_application_parent_class)->shutdown (application);

}

static void

gom_application_constructed (GObject *object)

{

  GomApplication *self = GOM_APPLICATION (object);

  const gchar *display_name;

  G_OBJECT_CLASS (gom_application_parent_class)->constructed (object);

  self->miner = g_object_new (self->miner_type, NULL);

  display_name = gom_miner_get_display_name (self->miner);

  gom_dbus_set_display_name (self->skeleton, display_name);

}

static void

gom_application_dispose (GObject *object)

{

  GomApplication *self = GOM_APPLICATION (object);

  g_clear_object (&self->cancellable);

  g_clear_object (&self->miner);

  g_clear_object (&self->skeleton);

  if (self->queue != NULL)

    {

      g_queue_free_full (self->queue, g_object_unref);

      self->queue = NULL;

    }

  G_OBJECT_CLASS (gom_application_parent_class)->dispose (object);

}

static void

gom_application_set_property (GObject *object,

                              guint prop_id,

                              const GValue *value,

                              GParamSpec *pspec)

{

  GomApplication *self = GOM_APPLICATION (object);

  switch (prop_id)

    {

    case PROP_MINER_TYPE:

      self->miner_type = g_value_get_gtype (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

    }

}

static void

gom_application_init (GomApplication *self)

{

  self->cancellable = g_cancellable_new ();

  self->skeleton = gom_dbus_skeleton_new ();

  g_signal_connect_swapped (self->skeleton,

                            "handle-insert-shared-content",

                            G_CALLBACK (gom_application_insert_shared_content),

                            self);

  g_signal_connect_swapped (self->skeleton, "handle-refresh-db", G_CALLBACK (gom_application_refresh_db), self);

  self->queue = g_queue_new ();

}

static void

gom_application_class_init (GomApplicationClass *klass)

{

  GObjectClass *oclass = G_OBJECT_CLASS (klass);

  GApplicationClass *application_class = G_APPLICATION_CLASS (klass);

  oclass->constructed = gom_application_constructed;

  oclass->dispose = gom_application_dispose;

  oclass->set_property = gom_application_set_property;

  application_class->dbus_register = gom_application_dbus_register;

  application_class->dbus_unregister = gom_application_dbus_unregister;

  application_class->shutdown = gom_application_shutdown;

  g_object_class_install_property (oclass,

                                   PROP_MINER_TYPE,

                                   g_param_spec_gtype ("miner-type",

                                                       "Miner type",

                                                       "A GType representing the miner class",

                                                       GOM_TYPE_MINER,

                                                       G_PARAM_CONSTRUCT_ONLY

                                                       | G_PARAM_STATIC_STRINGS

                                                       | G_PARAM_WRITABLE));

}

GApplication *

gom_application_new (const gchar *application_id,

                     GType miner_type)

{

  return g_object_new (GOM_TYPE_APPLICATION,

                       "application-id", application_id,

                       "flags", G_APPLICATION_IS_SERVICE,

                       "inactivity-timeout", AUTOQUIT_TIMEOUT,

                       "miner-type", miner_type,

                       NULL);

}