/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
 * Copyright © 2010 – 2013 Collabora Ltd.
 * Copyright © 2013 Intel Corporation
 *
 * 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 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, see <http://www.gnu.org/licenses/>.
 */

/* This class makes sure we have a GOA account for each Telepathy account
 * configured in the system.
 * Note that this handles only plain Telepathy accounts; the ones with
 * multiple capabilities (e.g. Facebook) are handled differently. */

#include "config.h"

#include <gio/gio.h>
#include <telepathy-glib/telepathy-glib.h>

#include "goatpaccountlinker.h"
#include "goabackend/goautils.h"

#define GOA_TP_ACCOUNT_LINKER_GET_PRIVATE(obj) \
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GOA_TYPE_TP_ACCOUNT_LINKER, \
                                GoaTpAccountLinkerPrivate))

G_DEFINE_TYPE (GoaTpAccountLinker, goa_tp_account_linker, G_TYPE_OBJECT)

struct _GoaTpAccountLinkerPrivate
{
  TpAccountManager *account_manager;
  GoaClient *goa_client;

  GHashTable *tp_accounts; /* owned gchar *id -> reffed TpAccount * */
  GHashTable *goa_accounts; /* owned gchar *id -> reffed GoaObject * */

  GQueue *remove_tp_account_queue;
};

/* The path of the Telepathy account is used as common identifier between
 * GOA and Telepathy */
static const gchar *
get_id_from_tp_account (TpAccount *tp_account)
{
  return tp_proxy_get_object_path (tp_account);
}

static const gchar *
get_id_from_goa_account (GoaAccount *goa_account)
{
  return goa_account_get_identity (goa_account);
}

static gboolean
is_telepathy_account (GoaAccount *goa_account)
{
  const gchar *type = goa_account_get_provider_type (goa_account);
  return g_str_has_prefix (type, "telepathy/");
}

static void
tp_account_removed_by_us_cb (GObject      *object,
                             GAsyncResult *res,
                             gpointer      user_data)
{
  TpAccount *tp_account = TP_ACCOUNT (object);
  GError *error = NULL;
  GTask *task = G_TASK (user_data);

  if (!tp_account_remove_finish (tp_account, res, &error))
    {
      g_critical ("Error removing Telepathy account %s: %s (%s, %d)",
          get_id_from_tp_account (tp_account),
          error->message,
          g_quark_to_string (error->domain),
          error->code);
      g_task_return_error (task, error);
      goto out;
    }

  g_task_return_boolean (task, TRUE);

 out:
  g_object_unref (task);
}

static void
remove_tp_account_queue_check (GoaTpAccountLinker *self)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  GList *l;

  if (priv->goa_client == NULL ||
      priv->account_manager == NULL ||
      !tp_proxy_is_prepared (priv->account_manager, TP_ACCOUNT_MANAGER_FEATURE_CORE))
    {
      /* Not everything is ready yet */
      return;
    }

  if (priv->remove_tp_account_queue->length == 0)
    return;

  for (l = priv->remove_tp_account_queue->head; l != NULL; l = l->next)
    {
      GTask *task = G_TASK (l->data);
      GoaAccount *goa_account;
      GoaObject *goa_object;
      TpAccount *tp_account;
      const gchar *id;

      goa_object = GOA_OBJECT (g_task_get_task_data (task));
      goa_account = goa_object_peek_account (goa_object);

      id = get_id_from_goa_account (goa_account);
      if (!g_hash_table_remove (priv->goa_accounts, id))
        {
          /* 1 - The user removes the Telepathy account (but not the GOA one)
           * 2 - We delete the corresponding GOA account and remove it
           *     from priv->goa_accounts
           * 3 - The Telepathy provider again tries to remove the
           *     corresponding Telepathy account
           */
          g_debug ("Ignoring removal of GOA account we asked to remove "
                   "(%s, Telepathy object path: %s)",
                   goa_account_get_id (goa_account),
                   id);
          g_task_return_boolean (task, TRUE);
          continue;
        }

      g_info ("GOA account %s for Telepathy account %s removed, "
              "removing Telepathy account",
              goa_account_get_id (goa_account), id);

      tp_account = g_hash_table_lookup (priv->tp_accounts, id);
      if (tp_account == NULL)
        {
          g_critical ("There is no Telepathy account for removed GOA "
                      "account %s (Telepathy object path: %s)",
                      goa_account_get_id (goa_account), id);
          g_task_return_boolean (task, TRUE);
          continue;
        }
      tp_account_remove_async (tp_account, tp_account_removed_by_us_cb, g_object_ref (task));
      g_hash_table_remove (priv->tp_accounts, id);
    }

  g_queue_foreach (priv->remove_tp_account_queue, (GFunc) g_object_unref, NULL);
  g_queue_clear (priv->remove_tp_account_queue);
}

static void
goa_account_chat_disabled_changed_cb (GoaAccount         *goa_account,
                                      GParamSpec         *spec,
                                      GoaTpAccountLinker *self)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  const gchar *id;
  TpAccount *tp_account;
  gboolean tp_enabled;
  gboolean goa_enabled;

  id = get_id_from_goa_account (goa_account);
  tp_account = g_hash_table_lookup (priv->tp_accounts, id);
  if (tp_account == NULL)
    return;

  goa_enabled = !goa_account_get_chat_disabled (goa_account);
  tp_enabled = tp_account_is_enabled (tp_account);
  if (tp_enabled != goa_enabled)
    {
      g_info ("The GOA account %s (Telepathy object path: %s) has been %s, "
          "propagating to Telepathy",
          goa_account_get_id (goa_account), id,
          goa_enabled ? "enabled" : "disabled");
      tp_account_set_enabled_async (tp_account, goa_enabled, NULL, NULL);
    }
}

static void
tp_account_chat_enabled_changed_cb (TpAccount          *tp_account,
                                    GParamSpec         *spec,
                                    GoaTpAccountLinker *self)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  const gchar *id;
  GoaObject *goa_object;
  GoaAccount *goa_account;
  gboolean tp_enabled;
  gboolean goa_enabled;

  id = get_id_from_tp_account (tp_account);
  goa_object = g_hash_table_lookup (priv->goa_accounts, id);
  if (goa_object == NULL)
    return;

  goa_account = goa_object_peek_account (goa_object);
  goa_enabled = !goa_account_get_chat_disabled (goa_account);
  tp_enabled = tp_account_is_enabled (tp_account);
  if (tp_enabled != goa_enabled)
    {
      g_info ("The Telepathy account %s has been %s, propagating to GOA",
          id, tp_enabled ? "enabled" : "disabled");
      /* When we set this property, the autogenerated code emits a notify
       * signal immediately even if the property hasn't changed, so
       * goa_account_chat_disabled_changed_cb() thinks that the property
       * changed back to the old value and a cycle starts.
       * The right notify signal will be emitted later when the property is
       * actually changed. */
      g_signal_handlers_block_by_func (goa_account,
          goa_account_chat_disabled_changed_cb, self);
      goa_account_set_chat_disabled (goa_account, !tp_enabled);
      g_signal_handlers_unblock_by_func (goa_account,
          goa_account_chat_disabled_changed_cb, self);
    }
}

static void
goa_account_created_cb (GoaManager   *manager,
                        GAsyncResult *res,
                        gpointer      user_data)
{
  TpAccount *tp_account = user_data;
  gchar *goa_account_object_path = NULL;
  GError *error = NULL;

  if (!goa_manager_call_add_account_finish (manager,
        &goa_account_object_path, res, &error))
    {
      g_critical ("Failed to create a GOA account for %s: %s (%s, %d)",
          get_id_from_tp_account (tp_account),
          error->message,
          g_quark_to_string (error->domain),
          error->code);
      g_error_free (error);
      goto out;
    }

  g_info ("Created new %s GOA account for Telepathy account %s",
      goa_account_object_path, get_id_from_tp_account (tp_account));

 out:
  g_object_unref (tp_account);
}

static void
create_goa_account (GoaTpAccountLinker *self,
                    TpAccount          *tp_account)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  GVariantBuilder credentials;
  GVariantBuilder details;
  gchar *provider;

  g_info ("Creating new GOA account for Telepathy account %s",
      get_id_from_tp_account (tp_account));

  g_variant_builder_init (&credentials, G_VARIANT_TYPE_VARDICT);

  g_variant_builder_init (&details, G_VARIANT_TYPE ("a{ss}"));
  g_variant_builder_add (&details, "{ss}", "ChatEnabled",
      tp_account_is_enabled (tp_account) ? "true" : "false");

  provider = g_strdup_printf ("telepathy/%s",
      tp_account_get_protocol_name (tp_account));

  goa_manager_call_add_account (goa_client_get_manager (priv->goa_client),
      provider,
      get_id_from_tp_account (tp_account),
      tp_account_get_display_name (tp_account),
      g_variant_builder_end (&credentials),
      g_variant_builder_end (&details),
      NULL, /* GCancellable* */
      (GAsyncReadyCallback) goa_account_created_cb,
      g_object_ref (tp_account));

  g_free (provider);
}

static gboolean
is_account_filtered (TpAccount *tp_account)
{
  const gchar *env;
  const gchar *id;

  env = g_getenv ("GOA_TELEPATHY_DEBUG_ACCOUNT_FILTER");
  if (env == NULL || env[0] == '\0')
    return FALSE;

  id = get_id_from_tp_account (tp_account);
  if (g_strstr_len (id, -1, env) != NULL)
    return FALSE; /* "env" is contained in "id" */
  else
    return TRUE;
}

static void
tp_account_added (GoaTpAccountLinker *self,
                  TpAccount          *tp_account)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  const gchar *id = get_id_from_tp_account (tp_account);
  GoaObject *goa_object = NULL;

  if (g_strcmp0 (tp_account_get_storage_provider (tp_account),
        "org.gnome.OnlineAccounts") == 0)
    {
      g_debug ("Skipping Telepathy account %s as it's handled directly by GOA", id);
      return;
    }

  if (is_account_filtered (tp_account))
    {
      g_debug ("The account %s is ignored for debugging reasons", id);
      return;
    }

  g_debug ("Telepathy account found: %s", id);

  g_hash_table_replace (priv->tp_accounts, g_strdup (id),
      g_object_ref (tp_account));

  g_signal_connect_object (tp_account, "notify::enabled",
      G_CALLBACK (tp_account_chat_enabled_changed_cb),
      self, 0);

  goa_object = g_hash_table_lookup (priv->goa_accounts, id);
  if (goa_object == NULL)
    {
      g_debug ("Found a Telepathy account with no corresponding "
          "GOA account: %s", id);
      create_goa_account (self, tp_account);
    }
  else
    {
      g_debug ("Found a Telepathy account with a matching "
          "GOA account: %s", id);
      /* Make sure the initial state is synced. */
      tp_account_chat_enabled_changed_cb (tp_account, NULL, self);
    }
}

static void
goa_account_removed_by_us_cb (GObject      *object,
                              GAsyncResult *res,
                              gpointer      user_data)
{
  /* This callback is only used for debugging */
  GoaAccount *goa_account = GOA_ACCOUNT (object);
  GError *error = NULL;

  if (!goa_account_call_remove_finish (goa_account, res, &error))
    {
      g_critical ("Error removing GOA account %s (Telepathy object path: %s): "
          "%s (%s, %d)",
          goa_account_get_id (goa_account),
          get_id_from_goa_account (goa_account),
          error->message,
          g_quark_to_string (error->domain),
          error->code);
      g_error_free (error);
    }
}

static void
tp_account_removed_cb (TpAccountManager *manager,
                       TpAccount        *tp_account,
                       gpointer          user_data)
{
  GoaTpAccountLinker *self = user_data;
  GoaTpAccountLinkerPrivate *priv = self->priv;
  const gchar *id = get_id_from_tp_account (tp_account);
  GoaObject *goa_object = NULL;

  if (!g_hash_table_remove (priv->tp_accounts, id))
    {
      /* 1 - The user removes the GOA account
       * 2 - We delete the corresponding Telepathy account and remove it
       *     from priv->tp_accounts
       * 3 - "account-removed" is emitted by the account manager
       * 4 - tp_account_removed_cb is called for an unknown account
       */
      g_debug ("Ignoring removal of Telepathy account we asked to "
          "remove (%s)", id);
      return;
    }

  g_info ("Telepathy account %s removed, removing corresponding "
      "GOA account", id);

  goa_object = g_hash_table_lookup (priv->goa_accounts, id);
  if (goa_object == NULL)
    {
      g_critical ("There is no GOA account for removed Telepathy "
          "account %s", id);
      return;
    }
  goa_account_call_remove (goa_object_peek_account (goa_object),
      NULL, /* cancellable */
      goa_account_removed_by_us_cb, NULL);
  g_hash_table_remove (priv->goa_accounts, id);
}

static void
tp_account_validity_changed_cb (TpAccountManager *manager,
                                TpAccount        *tp_account,
                                gboolean          valid,
                                gpointer          user_data)
{
  GoaTpAccountLinker *self = user_data;

  if (valid)
    tp_account_added (self, tp_account);
}

static void
goa_account_added_cb (GoaClient *client,
                      GoaObject *goa_object,
                      gpointer   user_data)
{
  GoaTpAccountLinker *self = user_data;
  GoaTpAccountLinkerPrivate *priv = self->priv;
  GoaAccount *goa_account = goa_object_peek_account (goa_object);
  const gchar *id = NULL;
  TpAccount *tp_account;

  if (!is_telepathy_account (goa_account))
    return;

  id = get_id_from_goa_account (goa_account);
  g_debug ("GOA account %s for Telepathy account %s added",
      goa_account_get_id (goa_account), id);

  g_signal_connect_object (goa_account, "notify::chat-disabled",
      G_CALLBACK (goa_account_chat_disabled_changed_cb), self, 0);

  g_hash_table_insert (priv->goa_accounts, g_strdup (id),
      g_object_ref (goa_object));

  tp_account = g_hash_table_lookup (priv->tp_accounts, id);
  if (tp_account != NULL)
    {
      /* The chat enabled status may have changed during the creation of the
       * GOA account, so we need to make sure it's synced. */
      tp_account_chat_enabled_changed_cb (tp_account, NULL, self);
    }
}

static void
start_if_ready (GoaTpAccountLinker *self)
{
  GoaTpAccountLinkerPrivate *priv = self->priv;
  GList *goa_accounts = NULL;
  GList *tp_accounts = NULL;
  GList *l = NULL;
  GHashTableIter iter;
  gpointer key, value;

  if (priv->goa_client == NULL ||
      priv->account_manager == NULL ||
      !tp_proxy_is_prepared (priv->account_manager,
        TP_ACCOUNT_MANAGER_FEATURE_CORE))
    {
      /* Not everything is ready yet */
      return;
    }

  g_debug ("Both GOA and Tp are ready, starting tracking of accounts");

  /* GOA */
  goa_accounts = goa_client_get_accounts (priv->goa_client);
  for (l = goa_accounts; l != NULL; l = l->next)
    goa_account_added_cb (priv->goa_client, l->data, self);
  g_list_free_full (goa_accounts, g_object_unref);

  g_signal_connect_object (priv->goa_client, "account-added",
      G_CALLBACK (goa_account_added_cb), self, 0);

  /* Telepathy */
  tp_accounts = tp_account_manager_dup_valid_accounts (priv->account_manager);
  for (l = tp_accounts; l != NULL; l = l->next)
    tp_account_added (self, l->data);
  g_list_free_full (tp_accounts, g_object_unref);

  g_signal_connect_object (priv->account_manager, "account-validity-changed",
      G_CALLBACK (tp_account_validity_changed_cb), self, 0);
  g_signal_connect_object (priv->account_manager, "account-removed",
      G_CALLBACK (tp_account_removed_cb), self, 0);

  /* Now we check if any Telepathy account was deleted while goa-daemon
   * was not running. */
  g_hash_table_iter_init (&iter, priv->goa_accounts);
  while (g_hash_table_iter_next (&iter, &key, &value))
    {
      const gchar *id = key;
      GoaObject *goa_object = value;

      if (!g_hash_table_lookup (priv->tp_accounts, id))
        {
          g_warning ("The Telepathy account %s was removed while the daemon "
              "was not running, removing the corresponding GOA account", id);
          goa_account_call_remove (goa_object_peek_account (goa_object),
              NULL, /* cancellable */
              goa_account_removed_by_us_cb,
              NULL); /* user data */
        }
    }

  remove_tp_account_queue_check (self);
}

static void
account_manager_prepared_cb (GObject      *object,
                             GAsyncResult *res,
                             gpointer      user_data)
{
  GoaTpAccountLinker *self = user_data;
  GError *error = NULL;

  if (!tp_proxy_prepare_finish (object, res, &error))
    {
      g_critical ("Error preparing AM: %s", error->message);
      g_clear_error (&error);
      return;
    }

  g_debug("Telepathy account manager prepared");
  start_if_ready (self);
}

static void
goa_client_new_cb (GObject      *object,
                   GAsyncResult *result,
                   gpointer      user_data)
{
  GoaTpAccountLinker *self = user_data;
  GoaTpAccountLinkerPrivate *priv = self->priv;
  GError *error = NULL;

  priv->goa_client = goa_client_new_finish (result, &error);
  if (priv->goa_client == NULL)
    {
      g_critical ("Error connecting to GOA: %s", error->message);
      g_clear_error (&error);
      return;
    }

  g_debug("GOA client ready");
  start_if_ready (self);
}

static void
goa_tp_account_linker_dispose (GObject *object)
{
  GoaTpAccountLinker *self = GOA_TP_ACCOUNT_LINKER (object);
  GoaTpAccountLinkerPrivate *priv = self->priv;

  if (priv->remove_tp_account_queue != NULL)
    {
      g_queue_free_full (priv->remove_tp_account_queue, g_object_unref);
      priv->remove_tp_account_queue = NULL;
    }

  g_clear_object (&priv->account_manager);
  g_clear_object (&priv->goa_client);

  g_clear_pointer (&priv->goa_accounts, g_hash_table_unref);
  g_clear_pointer (&priv->tp_accounts, g_hash_table_unref);

  G_OBJECT_CLASS (goa_tp_account_linker_parent_class)->dispose (object);
}

static void
goa_tp_account_linker_init (GoaTpAccountLinker *self)
{
  GoaTpAccountLinkerPrivate *priv;

  g_debug ("Starting GOA <-> Telepathy account linker");

  self->priv = GOA_TP_ACCOUNT_LINKER_GET_PRIVATE (self);
  priv = self->priv;

  priv->goa_accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
      g_free, g_object_unref);
  priv->tp_accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
      g_free, g_object_unref);

  priv->remove_tp_account_queue = g_queue_new ();

  priv->account_manager = tp_account_manager_dup ();
  tp_proxy_prepare_async (priv->account_manager, NULL,
      account_manager_prepared_cb, self);

  goa_client_new (NULL, goa_client_new_cb, self);
}

static void
goa_tp_account_linker_class_init (GoaTpAccountLinkerClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  goa_utils_initialize_client_factory ();

  g_type_class_add_private (gobject_class,
      sizeof (GoaTpAccountLinkerPrivate));

  gobject_class->dispose = goa_tp_account_linker_dispose;
}

GoaTpAccountLinker *
goa_tp_account_linker_new (void)
{
  return g_object_new (GOA_TYPE_TP_ACCOUNT_LINKER, NULL);
}

void
goa_tp_account_linker_remove_tp_account (GoaTpAccountLinker   *self,
                                         GoaObject            *object,
                                         GCancellable         *cancellable,
                                         GAsyncReadyCallback   callback,
                                         gpointer              user_data)
{
  GoaTpAccountLinkerPrivate *priv;
  GTask *task;

  g_return_if_fail (GOA_IS_TP_ACCOUNT_LINKER (self));
  priv = self->priv;

  g_return_if_fail (GOA_IS_OBJECT (object));
  g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

  task = g_task_new (self, cancellable, callback, user_data);
  g_task_set_source_tag (task, goa_tp_account_linker_remove_tp_account);
  g_task_set_task_data (task, g_object_ref (object), g_object_unref);
  g_queue_push_tail (priv->remove_tp_account_queue, g_object_ref (task));

  remove_tp_account_queue_check (self);

  g_object_unref (task);
}

gboolean
goa_tp_account_linker_remove_tp_account_finish (GoaTpAccountLinker  *self,
                                                GAsyncResult        *res,
                                                GError             **error)
{
  GTask *task;

  g_return_val_if_fail (GOA_IS_TP_ACCOUNT_LINKER (self), FALSE);
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  g_return_val_if_fail (g_task_is_valid (res, self), FALSE);
  task = G_TASK (res);

  g_return_val_if_fail (g_task_get_source_tag (task) == goa_tp_account_linker_remove_tp_account, FALSE);

  return g_task_propagate_boolean (task, error);
}