/*

 * gabble-presence-cache.c - Gabble's contact presence cache

 * Copyright (C) 2005 Collabora Ltd.

 *  and/or its subsidiaries. All rights reserved.

 *

 * 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 <stdlib.h>

#include <string.h>

#include "debug.h"

#include "disco.h" /* \o\ \o/ /o/ */

#include "gabble-presence.h"

#include "namespaces.h"

#include "util.h"

#include "handle-set.h"

#include "gintset.h"

#include "gabble-presence-cache.h"

#include "gabble-presence-cache-signals-marshal.h"

#include "gabble_enums.h"

#ifndef EMULATOR

G_DEFINE_TYPE (GabblePresenceCache, gabble_presence_cache, G_TYPE_OBJECT);

#endif

/* when five DIFFERENT guys report the same caps for a given bundle, it'll be enough */

#define CAPABILITY_BUNDLE_ENOUGH_TRUST 5

#define DEBUG_FLAG GABBLE_DEBUG_PRESENCE

#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

{

  PRESENCE_UPDATE,

  NICKNAME_UPDATE,

  CAPABILITIES_UPDATE,

  LAST_SIGNAL 

#ifdef EMULATOR  

  = LAST_SIGNAL_PRE_CACHE

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_pre_cache,guint)

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

    GET_STATIC_VAR_FROM_TLS(gabble_presence_cache_parent_class,gabble_pre_cache,gpointer)

	#define gabble_presence_cache_parent_class (*GET_WSD_VAR_NAME(gabble_presence_cache_parent_class,gabble_pre_cache,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_pre_cache,GType)

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

static void gabble_presence_cache_init (GabblePresenceCache *self); 

static void gabble_presence_cache_class_init (GabblePresenceCacheClass *klass);

static void gabble_presence_cache_class_intern_init (gpointer klass)

 { 

 gabble_presence_cache_parent_class = g_type_class_peek_parent (klass); 

 gabble_presence_cache_class_init ((GabblePresenceCacheClass*) klass);

 } 

 EXPORT_C GType gabble_presence_cache_get_type (void) 

 { 

 if ((g_define_type_id == 0))

 	{ static const GTypeInfo g_define_type_info = { sizeof (GabblePresenceCacheClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_presence_cache_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabblePresenceCache), 0, (GInstanceInitFunc) gabble_presence_cache_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabblePresenceCache"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

 };

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif

#define GABBLE_PRESENCE_CACHE_PRIV(account) ((GabblePresenceCachePrivate *)account->priv)

typedef struct _GabblePresenceCachePrivate GabblePresenceCachePrivate;

struct _GabblePresenceCachePrivate

{

  GabbleConnection *conn;

  gulong status_changed_cb;

  LmMessageHandler *lm_message_cb;

  GHashTable *presence;

  GabbleHandleSet *presence_handles;

  GHashTable *capabilities;

  GHashTable *disco_pending;

  guint caps_serial;

  gboolean dispose_has_run;

};

typedef struct _DiscoWaiter DiscoWaiter;

struct _DiscoWaiter

{

  GabbleHandleRepo *repo;

  GabbleHandle handle;

  gchar *resource;

  guint serial;

  gboolean disco_requested;

};

/**

 * disco_waiter_new ()

 */

static DiscoWaiter *

disco_waiter_new (GabbleHandleRepo *repo, GabbleHandle handle, const gchar *resource, guint serial)

{

  DiscoWaiter *waiter;

  g_assert (repo);

  gabble_handle_ref (repo, TP_HANDLE_TYPE_CONTACT, handle);

  waiter = g_new0 (DiscoWaiter, 1);

  waiter->repo = repo;

  waiter->handle = handle;

  waiter->resource = g_strdup (resource);

  waiter->serial = serial;

  gabble_debug (DEBUG_FLAG, "created waiter %p for handle %u with serial %u", waiter, handle, serial);

  return waiter;

}

static void

disco_waiter_free (DiscoWaiter *waiter)

{

  g_assert (NULL != waiter);

  gabble_debug (DEBUG_FLAG, "freeing waiter %p for handle %u with serial %u", waiter, waiter->handle, waiter->serial);

  gabble_handle_unref (waiter->repo, TP_HANDLE_TYPE_CONTACT, waiter->handle);

  g_free (waiter->resource);

  g_free (waiter);

}

static void

disco_waiter_list_free (GSList *list)

{

  GSList *i;

  gabble_debug (DEBUG_FLAG, "list %p", list);

  for (i = list; NULL != i; i = i->next)

    disco_waiter_free ((DiscoWaiter *) i->data);

  g_slist_free (list);

}

static guint

disco_waiter_list_get_request_count (GSList *list)

{

  guint c = 0;

  GSList *i;

  for (i = list; i; i = i->next)

    {

      DiscoWaiter *waiter = (DiscoWaiter *) i->data;

      if (waiter->disco_requested)

        c++;

    }

  return c;

}

typedef struct _CapabilityInfo CapabilityInfo;

struct _CapabilityInfo

{

  GabblePresenceCapabilities caps;

  GIntSet *guys;

  guint trust;

};

static CapabilityInfo *

capability_info_get (GabblePresenceCache *cache, const gchar *node,

    GabblePresenceCapabilities caps)

{

  GabblePresenceCachePrivate *priv = GABBLE_PRESENCE_CACHE_PRIV (cache);

  CapabilityInfo *info = g_hash_table_lookup (priv->capabilities, node);

  if (NULL == info)

    {

      info = g_new0 (CapabilityInfo, 1);

      info->caps = caps;

      info->guys = g_intset_new ();

      g_hash_table_insert (priv->capabilities, g_strdup (node), info);

    }

  return info;

}

static guint

capability_info_recvd (GabblePresenceCache *cache, const gchar *node,

        GabbleHandle handle, GabblePresenceCapabilities caps)

{

  CapabilityInfo *info = capability_info_get (cache, node, caps);

  /* Detect inconsistency in reported caps */

  if (info->caps != caps)

    {

      g_intset_clear (info->guys);

      info->caps = caps;

      info->trust = 0;

    }

  if (!g_intset_is_member (info->guys, handle))

    {

      g_intset_add (info->guys, handle);

      info->trust++;

    }

  return info->trust;

}

static void gabble_presence_cache_init (GabblePresenceCache *presence_cache);

static GObject * gabble_presence_cache_constructor (GType type, guint n_props,

    GObjectConstructParam *props);

static void gabble_presence_cache_dispose (GObject *object);

static void gabble_presence_cache_finalize (GObject *object);

static void gabble_presence_cache_set_property (GObject *object, guint

    property_id, const GValue *value, GParamSpec *pspec);

static void gabble_presence_cache_get_property (GObject *object, guint

    property_id, GValue *value, GParamSpec *pspec);

static GabblePresence *_cache_insert (GabblePresenceCache *cache,

    GabbleHandle handle);

static void gabble_presence_cache_status_changed_cb (GabbleConnection *,

    TpConnectionStatus, TpConnectionStatusReason, gpointer);

static LmHandlerResult gabble_presence_cache_lm_message_cb (LmMessageHandler*,

    LmConnection*, LmMessage*, gpointer);

static void

gabble_presence_cache_class_init (GabblePresenceCacheClass *klass)

{

  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  GParamSpec *param_spec;

  g_type_class_add_private (object_class, sizeof (GabblePresenceCachePrivate));

  object_class->constructor = gabble_presence_cache_constructor;

  object_class->dispose = gabble_presence_cache_dispose;

  object_class->finalize = gabble_presence_cache_finalize;

  object_class->get_property = gabble_presence_cache_get_property;

  object_class->set_property = gabble_presence_cache_set_property;

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

                                    "Gabble connection object that owns this "

                                    "presence cache.",

                                    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[PRESENCE_UPDATE] = g_signal_new (

    "presence-update",

    G_TYPE_FROM_CLASS (klass),

    G_SIGNAL_RUN_LAST,

    0,

    NULL, NULL,

    g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);

  signals[NICKNAME_UPDATE] = g_signal_new (

    "nickname-update",

    G_TYPE_FROM_CLASS (klass),

    G_SIGNAL_RUN_LAST,

    0,

    NULL, NULL,

    g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);

  signals[CAPABILITIES_UPDATE] = g_signal_new (

    "capabilities-update",

    G_TYPE_FROM_CLASS (klass),

    G_SIGNAL_RUN_LAST,

    0,

    NULL, NULL,

    gabble_presence_cache_marshal_VOID__UINT_UINT_UINT, G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);

}

static void

gabble_presence_cache_init (GabblePresenceCache *cache)

{

  GabblePresenceCachePrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (cache,

      GABBLE_TYPE_PRESENCE_CACHE, GabblePresenceCachePrivate);

  cache->priv = priv;

  priv->presence = g_hash_table_new_full (NULL, NULL, NULL, g_object_unref);

  priv->capabilities = g_hash_table_new (g_str_hash, g_str_equal);

  priv->disco_pending = g_hash_table_new_full (g_str_hash, g_str_equal,

    g_free, (GDestroyNotify) disco_waiter_list_free);

  priv->caps_serial = 1;

}

static GObject *

gabble_presence_cache_constructor (GType type, guint n_props,

                                   GObjectConstructParam *props)

{

  GObject *obj;

  GabblePresenceCachePrivate *priv;

  obj = G_OBJECT_CLASS (gabble_presence_cache_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_PRESENCE_CACHE_PRIV (GABBLE_PRESENCE_CACHE (obj));

  priv->status_changed_cb = g_signal_connect (priv->conn, "status-changed",

      G_CALLBACK (gabble_presence_cache_status_changed_cb), obj);

  return obj;

}

static void

gabble_presence_cache_dispose (GObject *object)

{

  GabblePresenceCache *self = GABBLE_PRESENCE_CACHE (object);

  GabblePresenceCachePrivate *priv = GABBLE_PRESENCE_CACHE_PRIV (self);

  if (priv->dispose_has_run)

    return;

  gabble_debug (DEBUG_FLAG, "dispose called");

  priv->dispose_has_run = TRUE;

  g_assert (priv->lm_message_cb == NULL);

  g_signal_handler_disconnect (priv->conn, priv->status_changed_cb);

  g_hash_table_destroy (priv->presence);

  priv->presence = NULL;

  handle_set_destroy (priv->presence_handles);

  priv->presence_handles = NULL;

  if (G_OBJECT_CLASS (gabble_presence_cache_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_presence_cache_parent_class)->dispose (object);

}

static void

gabble_presence_cache_finalize (GObject *object)

{

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

  G_OBJECT_CLASS (gabble_presence_cache_parent_class)->finalize (object);

}

static void

gabble_presence_cache_get_property (GObject    *object,

                                    guint       property_id,

                                    GValue     *value,

                                    GParamSpec *pspec)

{

  GabblePresenceCache *cache = GABBLE_PRESENCE_CACHE (object);

  GabblePresenceCachePrivate *priv = GABBLE_PRESENCE_CACHE_PRIV (cache);

  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_presence_cache_set_property (GObject     *object,

                                    guint        property_id,

                                    const GValue *value,

                                    GParamSpec   *pspec)

{

  GabblePresenceCache *cache = GABBLE_PRESENCE_CACHE (object);

  GabblePresenceCachePrivate *priv = GABBLE_PRESENCE_CACHE_PRIV (cache);

  GabbleHandleSet *new_presence_handles;

  switch (property_id) {

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      new_presence_handles = handle_set_new (priv->conn->handles, TP_HANDLE_TYPE_CONTACT);

      if (priv->presence_handles)

        {

          const GIntSet *add;

          GIntSet *tmp;

          add = handle_set_peek (priv->presence_handles);

          tmp = handle_set_update (new_presence_handles, add);

          handle_set_destroy (priv->presence_handles);

          g_intset_destroy (tmp);

        }

      priv->presence_handles = new_presence_handles;

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

#if 0

static gboolean

_presence_node_has_google_voice (LmMessageNode *pres_node)

{

  LmMessageNode *node;

  const gchar *cap_ext;

  gchar **features, **tmp;

  gboolean found = FALSE;

  node = lm_message_node_get_child_with_namespace (pres_node, "c", NS_CAPS);

  if (node == NULL);

    return FALSE;

  cap_ext = lm_message_node_get_attribute (node, "ext");

  if (cap_ext == NULL);

    return FALSE;

  features = g_strsplit (cap_ext, " ", 0);

  for (tmp = features; *tmp; tmp++)

    {

      if (!g_strdiff (tmp, "voice-v1"))

        {

          found = TRUE;

          break;

        }

    }

  g_strfreev (features);

  return found;

}

#endif

static void

gabble_presence_cache_status_changed_cb (GabbleConnection *conn,

                                         TpConnectionStatus status,

                                         TpConnectionStatusReason reason,

                                         gpointer data)

{

  GabblePresenceCache *cache = GABBLE_PRESENCE_CACHE (data);

  GabblePresenceCachePrivate *priv = GABBLE_PRESENCE_CACHE_PRIV (cache);

  g_assert (conn == priv->conn);

  switch (status)

    {

    case TP_CONN_STATUS_CONNECTING:

      g_assert (priv->lm_message_cb == NULL);

      priv->lm_message_cb = lm_message_handler_new (gabble_presence_cache_lm_message_cb,

                                                    cache, NULL);

      lm_connection_register_message_handler (priv->conn->lmconn,

                                              priv->lm_message_cb,

                                              LM_MESSAGE_TYPE_PRESENCE,

                                              LM_HANDLER_PRIORITY_LAST);

      lm_connection_register_message_handler (priv->conn->lmconn,

                                              priv->lm_message_cb,

                                              LM_MESSAGE_TYPE_MESSAGE,

                                              LM_HANDLER_PRIORITY_FIRST);

      break;

    case TP_CONN_STATUS_CONNECTED:

      /* TODO: emit self presence */

      break;

    case TP_CONN_STATUS_DISCONNECTED:

      g_assert (priv->lm_message_cb != NULL);

      lm_connection_unregister_message_handler (conn->lmconn,

                                                priv->lm_message_cb,

                                                LM_MESSAGE_TYPE_PRESENCE);

      lm_connection_unregister_message_handler (conn->lmconn,

                                                priv->lm_message_cb,

                                                LM_MESSAGE_TYPE_MESSAGE);

      lm_message_handler_unref (priv->lm_message_cb);

      priv->lm_message_cb = NULL;

      break;

    default:

      g_assert_not_reached ();

    }

}

static GabblePresenceId

_presence_node_get_status (LmMessageNode *pres_node)

{

  const gchar *presence_show;

  LmMessageNode *child_node = lm_message_node_get_child (pres_node, "show");

  if (!child_node)