/*

 * roster.c - Source for Gabble roster helper

 *

 * Copyright (C) 2006 Collabora Ltd.

 * 

 *

 * 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 St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <dbus/dbus-glib.h>

#include <string.h>

#include "telepathy-interfaces.h"

#include "tp-channel-factory-iface.h"

#include "debug.h"

#include "gabble-connection.h"

#include "gabble-roster-channel.h"

#include "namespaces.h"

#include "roster.h"

#include "util.h"

#include "gabble_enums.h"

#define DBUS_API_SUBJECT_TO_CHANGE

#define DEBUG_FLAG GABBLE_DEBUG_ROSTER

#define GOOGLE_ROSTER_VERSION "2"

#ifdef DEBUG_FLAG

//#define DEBUG(format, ...)

#define DEBUGGING 0

#define NODE_DEBUG(n, s)

#endif /* DEBUG_FLAG */

/* Properties */

enum

{

  PROP_CONNECTION = 1,

  LAST_PROPERTY

};

/* signal enum */

enum

{

  NICKNAME_UPDATE,

  LAST_SIGNAL 

#ifdef EMULATOR  

  = LAST_SIGNAL_ROSTER

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_roster,guint)

	#define signals (GET_WSD_VAR_NAME(signals,gabble_roster, s)())

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif

typedef struct _GabbleRosterPrivate GabbleRosterPrivate;

struct _GabbleRosterPrivate

{

  GabbleConnection *conn;

  LmMessageHandler *iq_cb;

  LmMessageHandler *presence_cb;

  GHashTable *channels;

  GHashTable *items;

  gboolean roster_received;

  gboolean dispose_has_run;

};

typedef enum

{

  GOOGLE_ITEM_TYPE_NORMAL = 0,

  GOOGLE_ITEM_TYPE_BLOCKED,

  GOOGLE_ITEM_TYPE_HIDDEN,

  GOOGLE_ITEM_TYPE_PINNED

} GoogleItemType;

typedef struct _GabbleRosterItem GabbleRosterItem;

struct _GabbleRosterItem

{

  GabbleRosterSubscription subscription;

  gboolean ask_subscribe;

  GoogleItemType google_type;

  gchar *name;

  gchar **groups;

};

static void gabble_roster_factory_iface_init ();

static void gabble_roster_init (GabbleRoster *roster);

static GObject * gabble_roster_constructor (GType type, guint n_props, GObjectConstructParam *props);

static void gabble_roster_dispose (GObject *object);

static void gabble_roster_finalize (GObject *object);

static void gabble_roster_set_property (GObject *object, guint property_id,

    const GValue *value, GParamSpec *pspec);

static void gabble_roster_get_property (GObject *object, guint property_id,

    GValue *value, GParamSpec *pspec);

static void _gabble_roster_item_free (GabbleRosterItem *item);

#ifndef EMULATOR

G_DEFINE_TYPE_WITH_CODE (GabbleRoster, gabble_roster, G_TYPE_OBJECT,

    G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_FACTORY_IFACE, gabble_roster_factory_iface_init));

#else

	GET_STATIC_VAR_FROM_TLS(gabble_roster_parent_class,gabble_roster,gpointer)

	#define gabble_roster_parent_class (*GET_WSD_VAR_NAME(gabble_roster_parent_class,gabble_roster,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_roster,GType)

	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_roster,s)())

	static void gabble_roster_init (GabbleRoster *self); 

	static void gabble_roster_class_init (GabbleRosterClass *klass); 

	static void gabble_roster_class_intern_init (gpointer klass) { gabble_roster_parent_class = g_type_class_peek_parent (klass); gabble_roster_class_init ((GabbleRosterClass*) klass); } EXPORT_C GType gabble_roster_get_type (void) { if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleRosterClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_roster_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleRoster), 0, (GInstanceInitFunc) gabble_roster_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleRoster"), &g_define_type_info, (GTypeFlags) 0); { { static const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) gabble_roster_factory_iface_init }; g_type_add_interface_static (g_define_type_id, tp_channel_factory_iface_get_type(), &g_implement_interface_info); } ; } } return g_define_type_id; }    ;

#endif

#define GABBLE_ROSTER_GET_PRIVATE(o)     ((GabbleRosterPrivate*) ((o)->priv));

static void

gabble_roster_class_init (GabbleRosterClass *gabble_roster_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_roster_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_roster_class, sizeof (GabbleRosterPrivate));

  object_class->constructor = gabble_roster_constructor;

  object_class->dispose = gabble_roster_dispose;

  object_class->finalize = gabble_roster_finalize;

  object_class->get_property = gabble_roster_get_property;

  object_class->set_property = gabble_roster_set_property;

  param_spec = g_param_spec_object ("connection", "GabbleConnection object",

                                    "Gabble connection object that owns this "

                                    "XMPP roster object.",

                                    GABBLE_TYPE_CONNECTION,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NICK |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class,

                                   PROP_CONNECTION,

                                   param_spec);

  signals[NICKNAME_UPDATE] = g_signal_new (

    "nickname-update",

    G_TYPE_FROM_CLASS (gabble_roster_class),

    G_SIGNAL_RUN_LAST,

    0,

    NULL, NULL,

    g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);

}

static void

gabble_roster_init (GabbleRoster *obj)

{

  GabbleRosterPrivate *priv =

     G_TYPE_INSTANCE_GET_PRIVATE (obj, GABBLE_TYPE_ROSTER, GabbleRosterPrivate);

  obj->priv = priv;

  priv->channels = g_hash_table_new_full (g_direct_hash,

                                          g_direct_equal,

                                          NULL,

                                          g_object_unref);

  priv->items = g_hash_table_new_full (g_direct_hash,

                                       g_direct_equal,

                                       NULL,

                                       (GDestroyNotify) _gabble_roster_item_free);

}

static GObject *

gabble_roster_constructor (GType type, guint n_props,

                           GObjectConstructParam *props)

{

  GObject *obj;

  /* GabbleRosterPrivate *priv; */

  obj = G_OBJECT_CLASS (gabble_roster_parent_class)->

           constructor (type, n_props, props);

  /* priv = GABBLE_ROSTER_GET_PRIVATE (GABBLE_ROSTER (obj)); */

  return obj;

}

void

gabble_roster_dispose (GObject *object)

{

  GabbleRoster *self = GABBLE_ROSTER (object);

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (self);

  if (priv->dispose_has_run)

    return;

  gabble_debug (DEBUG_FLAG, "dispose called");

  priv->dispose_has_run = TRUE;

  g_assert (priv->iq_cb == NULL);

  g_assert (priv->presence_cb == NULL);

  tp_channel_factory_iface_close_all (TP_CHANNEL_FACTORY_IFACE (object));

  g_assert (priv->channels == NULL);

  if (G_OBJECT_CLASS (gabble_roster_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_roster_parent_class)->dispose (object);

}

static void

item_handle_unref_foreach (gpointer key, gpointer data, gpointer user_data)

{

  GabbleHandle handle = (GabbleHandle) key;

  GabbleRosterPrivate *priv = (GabbleRosterPrivate *) user_data;

  gabble_handle_unref (priv->conn->handles, TP_HANDLE_TYPE_CONTACT, handle);

}

void

gabble_roster_finalize (GObject *object)

{

  GabbleRoster *self = GABBLE_ROSTER (object);

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (self);

  gabble_debug (DEBUG_FLAG, "called with %p", object);

  g_hash_table_foreach (priv->items, item_handle_unref_foreach, priv);

  g_hash_table_destroy (priv->items);

  G_OBJECT_CLASS (gabble_roster_parent_class)->finalize (object);

}

static void

gabble_roster_get_property (GObject    *object,

                            guint       property_id,

                            GValue     *value,

                            GParamSpec *pspec)

{

  GabbleRoster *roster = GABBLE_ROSTER (object);

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (roster);

  switch (property_id) {

    case PROP_CONNECTION:

      g_value_set_object (value, priv->conn);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_roster_set_property (GObject     *object,

                            guint        property_id,

                            const GValue *value,

                            GParamSpec   *pspec)

{

  GabbleRoster *roster = GABBLE_ROSTER (object);

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (roster);

  switch (property_id) {

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

_gabble_roster_item_free (GabbleRosterItem *item)

{

  g_assert (item != NULL);

  g_strfreev (item->groups);

  g_free (item->name);

  g_free (item);

}

static const gchar *

_subscription_to_string (GabbleRosterSubscription subscription)

{

  switch (subscription)

    {

      case GABBLE_ROSTER_SUBSCRIPTION_NONE:

        return "none";

      case GABBLE_ROSTER_SUBSCRIPTION_FROM:

        return "from";

      case GABBLE_ROSTER_SUBSCRIPTION_TO:

        return "to";

      case GABBLE_ROSTER_SUBSCRIPTION_BOTH:

        return "both";

      case GABBLE_ROSTER_SUBSCRIPTION_REMOVE:

        return "remove";

      default:

        g_assert_not_reached ();

        return NULL;

    }

}

static GabbleRosterSubscription

_parse_item_subscription (LmMessageNode *item_node)

{

  const gchar *subscription;

  g_assert (item_node != NULL);

  subscription = lm_message_node_get_attribute (item_node, "subscription");

  if (NULL == subscription || 0 == strcmp (subscription, "none"))

    return GABBLE_ROSTER_SUBSCRIPTION_NONE;

  else if (0 == strcmp (subscription, "from"))

    return GABBLE_ROSTER_SUBSCRIPTION_FROM;

  else if (0 == strcmp (subscription, "to"))

    return GABBLE_ROSTER_SUBSCRIPTION_TO;

  else if (0 == strcmp (subscription, "both"))

    return GABBLE_ROSTER_SUBSCRIPTION_BOTH;

  else if (0 == strcmp (subscription, "remove"))

    return GABBLE_ROSTER_SUBSCRIPTION_REMOVE;

  else

    {

       NODE_DEBUG (item_node, "got unexpected subscription value");

      return GABBLE_ROSTER_SUBSCRIPTION_NONE;

    }

}

static gchar **

_parse_item_groups (LmMessageNode *item_node)

{

  LmMessageNode *group_node;

  GPtrArray *strv;

  strv = g_ptr_array_new ();

  for (group_node = item_node->children;

      NULL != group_node;

      group_node = group_node->next)

    {

      if (0 != strcmp (group_node->name, "group"))

        continue;

      if (NULL == group_node->value)

        continue;

      g_ptr_array_add (strv, g_strdup (group_node->value));

    }

  g_ptr_array_add (strv, NULL);

  return (gchar **) g_ptr_array_free (strv, FALSE);

}

static const gchar *

_google_item_type_to_string (GoogleItemType google_type)

{

  switch (google_type)

    {

      case GOOGLE_ITEM_TYPE_NORMAL:

        return NULL;

      case GOOGLE_ITEM_TYPE_BLOCKED:

        return "B";

      case GOOGLE_ITEM_TYPE_HIDDEN:

        return "H";

      case GOOGLE_ITEM_TYPE_PINNED:

        return "P";

    }

  g_assert_not_reached ();

  return NULL;

}

static GoogleItemType

_parse_google_item_type (LmMessageNode *item_node)

{

  const gchar *google_type;

  g_assert (item_node != NULL);

  google_type = lm_message_node_get_attribute (item_node, "gr:t");

  if (NULL == google_type)

    return GOOGLE_ITEM_TYPE_NORMAL;

  else if (!g_strdiff (google_type, "B"))

    return GOOGLE_ITEM_TYPE_BLOCKED;

  else if (!g_strdiff (google_type, "H"))

    return GOOGLE_ITEM_TYPE_HIDDEN;

  else if (!g_strdiff (google_type, "P"))

    return GOOGLE_ITEM_TYPE_PINNED;

  NODE_DEBUG (item_node, "got unexpected google contact type value");

  return GOOGLE_ITEM_TYPE_NORMAL;

}

static gboolean

_google_roster_item_should_keep (LmMessageNode *item_node,

                                 GabbleRosterItem *item)

{

  const gchar *attr;

  /* skip automatically subscribed Google roster items */

  attr = lm_message_node_get_attribute (item_node, "gr:autosub");

  if (!g_strdiff (attr, "true"))

    return FALSE;

  /* skip email addresses that replied to an invite */

  attr = lm_message_node_get_attribute (item_node, "gr:alias-for");

  if (attr != NULL)

    return FALSE;

  /* allow items that we've requested a subscription from */

  if (item->ask_subscribe)

    return TRUE;

  if (item->subscription != GABBLE_ROSTER_SUBSCRIPTION_NONE)

    return TRUE;

  /* discard anything else */

  return FALSE;

}

static GabbleRosterItem *

_gabble_roster_item_get (GabbleRoster *roster,

                         GabbleHandle handle)

{

  GabbleRosterItem *item;

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (roster);

  g_assert (roster != NULL);

  g_assert (GABBLE_IS_ROSTER (roster));

  g_assert (gabble_handle_is_valid (priv->conn->handles,

        TP_HANDLE_TYPE_CONTACT, handle, NULL));

  item = g_hash_table_lookup (priv->items, GINT_TO_POINTER (handle));

  if (NULL == item)

    {

      item = g_new0 (GabbleRosterItem, 1);

      gabble_handle_ref (priv->conn->handles, TP_HANDLE_TYPE_CONTACT, handle);

      g_hash_table_insert (priv->items, GINT_TO_POINTER (handle), item);

    }

  return item;

}

static void

_gabble_roster_item_remove (GabbleRoster *roster,

                            GabbleHandle handle)

{

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (roster);

  g_assert (roster != NULL);

  g_assert (GABBLE_IS_ROSTER (roster));

  g_assert (gabble_handle_is_valid (priv->conn->handles,

        TP_HANDLE_TYPE_CONTACT, handle, NULL));

  g_hash_table_remove (priv->items, GINT_TO_POINTER (handle));

  gabble_handle_unref (priv->conn->handles, TP_HANDLE_TYPE_CONTACT, handle);

}

static GabbleRosterItem *

_gabble_roster_item_update (GabbleRoster *roster,

                            GabbleHandle handle,

                            LmMessageNode *node,

                            gboolean google_roster_mode)

{

  GabbleRosterItem *item;

  const gchar *ask, *name;

  GabbleRosterPrivate *priv = GABBLE_ROSTER_GET_PRIVATE (roster);

  g_assert (roster != NULL);

  g_assert (GABBLE_IS_ROSTER (roster));

  g_assert (gabble_handle_is_valid (priv->conn->handles,

        TP_HANDLE_TYPE_CONTACT, handle, NULL));

  g_assert (node != NULL);

  item = _gabble_roster_item_get (roster, handle);

  item->subscription = _parse_item_subscription (node);

  ask = lm_message_node_get_attribute (node, "ask");

  if (NULL != ask && 0 == strcmp (ask, "subscribe"))

    item->ask_subscribe = TRUE;

  else

    item->ask_subscribe = FALSE;

  if (google_roster_mode)

    {

      item->google_type = _parse_google_item_type (node);

      /* discard roster item if strange, just hide it if it's hidden */

      if (item->google_type == GOOGLE_ITEM_TYPE_HIDDEN)

        {

          gabble_debug (DEBUG_FLAG, "Google roster: caching hidden contact %d (%s)", handle,

              lm_message_node_get_attribute (node, "jid"));

          item->subscription = GABBLE_ROSTER_SUBSCRIPTION_NONE;