/*
 * Copyright (C) 2005-2007 Imendio AB
 * Copyright (C) 2007-2011 Collabora Ltd.
 *
 * 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 St, Fifth Floor,
 * Boston, MA  02110-1301  USA
 *
 * Authors: Mikael Hallendal <micke@imendio.com>
 *          Martyn Russell <martyn@imendio.com>
 *          Xavier Claessens <xclaesse@gmail.com>
 *          Travis Reitter <travis.reitter@collabora.co.uk>
 */

#include "config.h"
#include "empathy-individual-store-manager.h"

#define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
#include "empathy-debug.h"

struct _EmpathyIndividualStoreManagerPriv
{
  EmpathyIndividualManager *manager;
  gboolean setup_idle_id;
};

enum
{
  PROP_0,
  PROP_INDIVIDUAL_MANAGER,
};


G_DEFINE_TYPE (EmpathyIndividualStoreManager, empathy_individual_store_manager,
    EMPATHY_TYPE_INDIVIDUAL_STORE);

static void
individual_store_manager_members_changed_cb (EmpathyIndividualManager *manager,
    const gchar *message,
    GList *added,
    GList *removed,
    guint reason,
    EmpathyIndividualStoreManager *self)
{
  GList *l;
  EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);

  for (l = removed; l; l = l->next)
    {
      DEBUG ("Individual %s (%s) %s",
          folks_individual_get_id (l->data),
          folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (l->data)),
          "removed");

      individual_store_remove_individual_and_disconnect (store, l->data);
    }

  for (l = added; l; l = l->next)
    {
      DEBUG ("Individual %s (%s) %s", folks_individual_get_id (l->data),
          folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (l->data)),
          "added");

      individual_store_add_individual_and_connect (store, l->data);
    }
}

static void
individual_store_manager_groups_changed_cb (EmpathyIndividualManager *manager,
    FolksIndividual *individual,
    gchar *group,
    gboolean is_member,
    EmpathyIndividualStoreManager *self)
{
  EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);

  DEBUG ("Updating groups for individual %s (%s)",
      folks_individual_get_id (individual),
      folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));

  /* We do this to make sure the groups are correct, if not, we
   * would have to check the groups already set up for each
   * contact and then see what has been updated.
   */
  empathy_individual_store_refresh_individual (store, individual);
}

static gboolean
individual_store_manager_manager_setup (gpointer user_data)
{
  EmpathyIndividualStoreManager *self = user_data;
  GList *individuals;

  /* Signal connection. */

  DEBUG ("handling individual renames unimplemented");

  g_signal_connect (self->priv->manager,
      "members-changed",
      G_CALLBACK (individual_store_manager_members_changed_cb), self);

  g_signal_connect (self->priv->manager,
      "groups-changed",
      G_CALLBACK (individual_store_manager_groups_changed_cb), self);

  /* Add contacts already created. */
  individuals = empathy_individual_manager_get_members (self->priv->manager);
  if (individuals != NULL)
    {
      individual_store_manager_members_changed_cb (self->priv->manager, "initial add",
          individuals, NULL, 0, self);
      g_list_free (individuals);
    }

  self->priv->setup_idle_id = 0;
  return FALSE;
}

static void
individual_store_manager_set_individual_manager (
    EmpathyIndividualStoreManager *self,
    EmpathyIndividualManager *manager)
{
  g_assert (self->priv->manager == NULL); /* construct only */
  self->priv->manager = g_object_ref (manager);

  /* Let a chance to have all properties set before populating */
  self->priv->setup_idle_id = g_idle_add (
      individual_store_manager_manager_setup, self);
}

static void
individual_store_manager_member_renamed_cb (EmpathyIndividualManager *manager,
    FolksIndividual *old_individual,
    FolksIndividual *new_individual,
    guint reason,
    const gchar *message,
    EmpathyIndividualStoreManager *self)
{
  EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (self);

  DEBUG ("Individual %s (%s) renamed to %s",
      folks_individual_get_id (old_individual),
      folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (old_individual)),
      folks_individual_get_id (new_individual));

  /* remove old contact */
  individual_store_remove_individual_and_disconnect (store, old_individual);

  /* add the new contact */
  individual_store_add_individual_and_connect (store, new_individual);
}

static void
individual_store_manager_dispose (GObject *object)
{
  EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
      object);
  EmpathyIndividualStore *store = EMPATHY_INDIVIDUAL_STORE (object);
  GList *individuals, *l;

  individuals = empathy_individual_manager_get_members (self->priv->manager);
  for (l = individuals; l; l = l->next)
    {
      empathy_individual_store_disconnect_individual (store,
          FOLKS_INDIVIDUAL (l->data));
    }
  tp_clear_pointer (&individuals, g_list_free);

  if (self->priv->manager != NULL)
    {
      g_signal_handlers_disconnect_by_func (self->priv->manager,
          G_CALLBACK (individual_store_manager_member_renamed_cb), object);
      g_signal_handlers_disconnect_by_func (self->priv->manager,
          G_CALLBACK (individual_store_manager_members_changed_cb), object);
      g_signal_handlers_disconnect_by_func (self->priv->manager,
          G_CALLBACK (individual_store_manager_groups_changed_cb), object);
      g_clear_object (&self->priv->manager);
    }

  if (self->priv->setup_idle_id != 0)
    {
      g_source_remove (self->priv->setup_idle_id);
      self->priv->setup_idle_id = 0;
    }

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

static void
individual_store_manager_get_property (GObject *object,
    guint param_id,
    GValue *value,
    GParamSpec *pspec)
{
  EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
      object);

  switch (param_id)
    {
    case PROP_INDIVIDUAL_MANAGER:
      g_value_set_object (value, self->priv->manager);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
    };
}

static void
individual_store_manager_set_property (GObject *object,
    guint param_id,
    const GValue *value,
    GParamSpec *pspec)
{
  switch (param_id)
    {
    case PROP_INDIVIDUAL_MANAGER:
      individual_store_manager_set_individual_manager (
          EMPATHY_INDIVIDUAL_STORE_MANAGER (object),
          g_value_get_object (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
      break;
    };
}

static void
individual_store_manager_reload_individuals (EmpathyIndividualStore *store)
{
  EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
      store);
  GList *contacts;

  contacts = empathy_individual_manager_get_members (self->priv->manager);

  individual_store_manager_members_changed_cb (self->priv->manager,
      "re-adding members: toggled group visibility",
      contacts, NULL, 0, self);

  g_list_free (contacts);
}

static gboolean
individual_store_manager_initial_loading (EmpathyIndividualStore *store)
{
  EmpathyIndividualStoreManager *self = EMPATHY_INDIVIDUAL_STORE_MANAGER (
      store);

  return self->priv->setup_idle_id != 0;
}

static void
empathy_individual_store_manager_class_init (
    EmpathyIndividualStoreManagerClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  EmpathyIndividualStoreClass *store_class = EMPATHY_INDIVIDUAL_STORE_CLASS (
      klass);

  object_class->dispose = individual_store_manager_dispose;
  object_class->get_property = individual_store_manager_get_property;
  object_class->set_property = individual_store_manager_set_property;

  store_class->reload_individuals = individual_store_manager_reload_individuals;
  store_class->initial_loading = individual_store_manager_initial_loading;

  g_object_class_install_property (object_class,
      PROP_INDIVIDUAL_MANAGER,
      g_param_spec_object ("individual-manager",
          "Individual manager",
          "Individual manager",
          EMPATHY_TYPE_INDIVIDUAL_MANAGER,
          G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));

  g_type_class_add_private (object_class,
      sizeof (EmpathyIndividualStoreManagerPriv));
}

static void
empathy_individual_store_manager_init (EmpathyIndividualStoreManager *self)
{
  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
      EMPATHY_TYPE_INDIVIDUAL_STORE_MANAGER, EmpathyIndividualStoreManagerPriv);
}

EmpathyIndividualStoreManager *
empathy_individual_store_manager_new (EmpathyIndividualManager *manager)
{
  g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (manager), NULL);

  return g_object_new (EMPATHY_TYPE_INDIVIDUAL_STORE_MANAGER,
      "individual-manager", manager, NULL);
}

EmpathyIndividualManager *
empathy_individual_store_manager_get_manager (
    EmpathyIndividualStoreManager *self)
{
  g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_STORE_MANAGER (self), FALSE);

  return self->priv->manager;
}