/*

 * vcard-manager.c - Source for Gabble vCard lookup 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 <dbus/dbus-glib-lowlevel.h>

#include "debug.h"

#include "gabble-connection.h"

#include "namespaces.h"

#include "telepathy-helpers.h"

#include "util.h"

#include "vcard-manager.h"

#include "gabble_enums.h"

#define DBUS_API_SUBJECT_TO_CHANGE

#define DEBUG_FLAG GABBLE_DEBUG_VCARD

#define DEFAULT_REQUEST_TIMEOUT 20000

#ifdef DEBUG_FLAG

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

#define DEBUGGING 0

#define NODE_DEBUG(n, s)

#endif /* DEBUG_FLAG */

#ifndef EMULATOR

G_DEFINE_TYPE(GabbleVCardManager, gabble_vcard_manager, G_TYPE_OBJECT);

#endif

/* signal enum */

enum

{

    NICKNAME_UPDATE,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_VCARD_MGR

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_vcard_mgr,guint)

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

	GET_STATIC_VAR_FROM_TLS(quark1,gabble_vcard_mgr,GQuark)

	#define quark1 (*GET_WSD_VAR_NAME(quark1,gabble_vcard_mgr, s)())	

	GET_STATIC_VAR_FROM_TLS(quark2,gabble_vcard_mgr,GQuark)

	#define quark2 (*GET_WSD_VAR_NAME(quark2,gabble_vcard_mgr, s)())

	GET_STATIC_VAR_FROM_TLS(gabble_vcard_manager_parent_class,gabble_vcard_mgr,gpointer)

	#define gabble_vcard_manager_parent_class (*GET_WSD_VAR_NAME(gabble_vcard_manager_parent_class,gabble_vcard_mgr,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_vcard_mgr,GType)

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

    GET_STATIC_ARRAY_FROM_TLS(NO_ALIAS,gabble_vcard_mgr,gchar)

	#define NO_ALIAS (GET_WSD_VAR_NAME(NO_ALIAS,gabble_vcard_mgr,s)())

static void gabble_vcard_manager_init (GabbleVCardManager *self); 

static void gabble_vcard_manager_class_init (GabbleVCardManagerClass *klass); 

static void gabble_vcard_manager_class_intern_init (gpointer klass)

 { 

 gabble_vcard_manager_parent_class = g_type_class_peek_parent (klass);

 gabble_vcard_manager_class_init ((GabbleVCardManagerClass*) klass);

  }

   EXPORT_C GType gabble_vcard_manager_get_type (void) 

   {

   if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleVCardManagerClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_vcard_manager_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleVCardManager), 0, (GInstanceInitFunc) gabble_vcard_manager_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleVCardManager"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; } ;

#else

	static guint signals[LAST_SIGNAL] = {0};

    static const gchar *NO_ALIAS = "none";

#endif

/* Properties */

enum

{

  PROP_CONNECTION = 1,

  LAST_PROPERTY

};

typedef struct _GabbleVCardManagerPrivate GabbleVCardManagerPrivate;

struct _GabbleVCardManagerPrivate

{

  GabbleConnection *connection;

  GList *requests;

  gboolean dispose_has_run;

};

struct _GabbleVCardManagerRequest

{

  GabbleVCardManager *manager;

  guint timer_id;

  guint timeout;

  GabbleHandle handle;

  gchar **edit_args;

  GabbleVCardManagerCb callback;

  gpointer user_data;

  GObject *bound_object;

};

GQuark

gabble_vcard_manager_error_quark (void)

{

#ifndef EMULATOR

  static GQuark quark1 = 0;

#endif

  if (!quark1)

    quark1 = g_quark_from_static_string ("gabble-vcard-manager-error");

  return quark1;

}

GQuark

gabble_vcard_manager_cache_quark (void)

{

#ifndef EMULATOR

  static GQuark quark2 = 0;

#endif

  if (!quark2)

    quark2 = g_quark_from_static_string ("gabble-vcard-manager-cache");

  return quark2;

}

#define GABBLE_VCARD_MANAGER_GET_PRIVATE(o)     ((GabbleVCardManagerPrivate*)((o)->priv));

static void

gabble_vcard_manager_init (GabbleVCardManager *obj)

{

  GabbleVCardManagerPrivate *priv =

     G_TYPE_INSTANCE_GET_PRIVATE (obj, GABBLE_TYPE_VCARD_MANAGER, GabbleVCardManagerPrivate);

  obj->priv = priv;

}

static void gabble_vcard_manager_set_property (GObject *object, guint property_id,

    const GValue *value, GParamSpec *pspec);

static void gabble_vcard_manager_get_property (GObject *object, guint property_id,

    GValue *value, GParamSpec *pspec);

static void gabble_vcard_manager_dispose (GObject *object);

static void gabble_vcard_manager_finalize (GObject *object);

static void

gabble_vcard_manager_class_init (GabbleVCardManagerClass *gabble_vcard_manager_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_vcard_manager_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_vcard_manager_class, sizeof (GabbleVCardManagerPrivate));

  object_class->get_property = gabble_vcard_manager_get_property;

  object_class->set_property = gabble_vcard_manager_set_property;

  object_class->dispose = gabble_vcard_manager_dispose;

  object_class->finalize = gabble_vcard_manager_finalize;

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

                                    "Gabble connection object that owns this "

                                    "vCard lookup helper 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);

  /* signal definitions */

  signals[NICKNAME_UPDATE] =

    g_signal_new ("nickname-update",

                  G_TYPE_FROM_CLASS (gabble_vcard_manager_class),

                  G_SIGNAL_RUN_LAST,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__UINT,

                  G_TYPE_NONE, 1, G_TYPE_UINT);

}

static void

gabble_vcard_manager_get_property (GObject    *object,

                                   guint       property_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  GabbleVCardManager *chan = GABBLE_VCARD_MANAGER (object);

  GabbleVCardManagerPrivate *priv = GABBLE_VCARD_MANAGER_GET_PRIVATE (chan);

  switch (property_id) {

    case PROP_CONNECTION:

      g_value_set_object (value, priv->connection);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_vcard_manager_set_property (GObject     *object,

                                   guint        property_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  GabbleVCardManager *chan = GABBLE_VCARD_MANAGER (object);

  GabbleVCardManagerPrivate *priv = GABBLE_VCARD_MANAGER_GET_PRIVATE (chan);

  switch (property_id) {

    case PROP_CONNECTION:

      priv->connection = g_value_get_object (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void cancel_request (GabbleVCardManagerRequest *request);

void

gabble_vcard_manager_dispose (GObject *object)

{

  DBusGProxy *bus_proxy;

  GabbleVCardManager *self = GABBLE_VCARD_MANAGER (object);

  GabbleVCardManagerPrivate *priv = GABBLE_VCARD_MANAGER_GET_PRIVATE (self);

  bus_proxy = tp_get_bus_proxy ();

  if (priv->dispose_has_run)

    return;

  priv->dispose_has_run = TRUE;

  /* cancel request removes the element from the list after cancelling */

  while (priv->requests)

    cancel_request (priv->requests->data);

  if (G_OBJECT_CLASS (gabble_vcard_manager_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_vcard_manager_parent_class)->dispose (object);

}

void

gabble_vcard_manager_finalize (GObject *object)

{

  G_OBJECT_CLASS (gabble_vcard_manager_parent_class)->finalize (object);

}

static void

status_changed_cb (GObject *object,

                   guint status,

                   guint reason,

                   gpointer user_data)

{

  GabbleVCardManager *self = GABBLE_VCARD_MANAGER (user_data);

  GabbleConnection *conn = GABBLE_CONNECTION (object);

  if (status == TP_CONN_STATUS_CONNECTED)

    {

      gchar *alias;

      GabbleConnectionAliasSource alias_src;

      /* if we have a better alias, patch it into our vCard on the server */

      alias_src = _gabble_connection_get_cached_alias (conn,

                                                       conn->self_handle,

                                                       &alias);

      if (alias_src > GABBLE_CONNECTION_ALIAS_FROM_VCARD)

        {

          /* ignore errors, just kick off the request in the background */

          gabble_vcard_manager_edit (self, 0, NULL, NULL, G_OBJECT (conn),

                                     NULL, "NICKNAME", alias, NULL);

        }

      else

        {

          /* find out our own alias, so it's in the cache; again,

           * there's nothing useful we can do with errors really

           */

          gabble_vcard_manager_request (self, conn->self_handle,

                                        0, NULL, NULL, NULL, NULL);

        }

      g_free(alias);

    }

}

/**

 * gabble_vcard_manager_new:

 * @conn: The #GabbleConnection to use for vCard lookup

 *

 * Creates an object to use for Jabber vCard lookup (JEP 0054).

 * There should be one of these per connection

 */

GabbleVCardManager *

gabble_vcard_manager_new (GabbleConnection *conn)

{

  GabbleVCardManager *self;

  g_return_val_if_fail (GABBLE_IS_CONNECTION (conn), NULL);

  self = GABBLE_VCARD_MANAGER (g_object_new (GABBLE_TYPE_VCARD_MANAGER, "connection", conn, NULL));

  g_signal_connect (conn, "status-changed",

                    G_CALLBACK (status_changed_cb), self);

  return self;

}

static void notify_delete_request (gpointer data, GObject *obj);

static void

delete_request (GabbleVCardManagerRequest *request)

{

  GabbleVCardManager *manager = request->manager;

  GabbleVCardManagerPrivate *priv;

  gabble_debug (DEBUG_FLAG, "Discarding request %p", request);

  g_assert (NULL != request);

  g_assert (GABBLE_IS_VCARD_MANAGER (manager));

  priv = GABBLE_VCARD_MANAGER_GET_PRIVATE (manager);

  g_assert (NULL != g_list_find (priv->requests, request));

  priv->requests = g_list_remove (priv->requests, request);

  if (NULL != request->bound_object)

    {

      g_object_weak_unref (request->bound_object, notify_delete_request, request);

    }

  if (0 != request->timer_id)

    {

      g_source_remove (request->timer_id);

    }

  gabble_handle_unref (priv->connection->handles, TP_HANDLE_TYPE_CONTACT,

                       request->handle);

  g_strfreev (request->edit_args);

  g_free (request);

}

static gboolean

timeout_request (gpointer data)

{

  GabbleVCardManagerRequest *request = (GabbleVCardManagerRequest*) data;

  GError *err;

  g_return_val_if_fail (data != NULL, FALSE);

  err = g_error_new (GABBLE_VCARD_MANAGER_ERROR, GABBLE_VCARD_MANAGER_ERROR_TIMEOUT,

      "Request timed out");

  gabble_debug (DEBUG_FLAG, "Request %p timed out, notifying callback %p",

         request, request->callback);

  if (request->callback)

    {

      (request->callback)(request->manager, request, request->handle,

                          NULL, err, request->user_data);

    }

  g_error_free (err);

  request->timer_id = 0;

  delete_request (request);

  return FALSE;

}

static void

cancel_request (GabbleVCardManagerRequest *request)

{

  GError *err;

  g_assert (request != NULL);

  err = g_error_new (GABBLE_VCARD_MANAGER_ERROR, GABBLE_VCARD_MANAGER_ERROR_CANCELLED,

      "Request cancelled");

  gabble_debug (DEBUG_FLAG, "Request %p cancelled, notifying callback %p",

         request, request->callback);

  if (request->callback)

    {

      (request->callback)(request->manager, request, request->handle,

                          NULL, err, request->user_data);

    }

  g_error_free (err);

  delete_request (request);

}

static void

observe_vcard (GabbleConnection *conn, GabbleVCardManager *manager,

               GabbleHandle handle, LmMessageNode *vcard_node)

{

  LmMessageNode *nick_node = lm_message_node_get_child (vcard_node,

                                                        "NICKNAME");

  gabble_debug (DEBUG_FLAG, "Observing vCard for %u", handle);

  NODE_DEBUG(vcard_node, "their vCard is");

  if (nick_node)

    {

      const gchar *nick = lm_message_node_get_value (nick_node);

      gabble_debug (DEBUG_FLAG, "%u has <NICKNAME> \"%s\"", handle, nick ? nick : "(null)");

      if (nick && *nick)

        {

          /* nicknames are comma-separated, let's use the first one */

          gchar **bits = g_strsplit (nick, ",", 2);

          if (bits[0])

            {

              gchar *alias = g_strdup (bits[0]);

              gabble_debug (DEBUG_FLAG, "... using \"%s\" as their alias", alias);

              g_signal_emit (G_OBJECT (manager), signals[NICKNAME_UPDATE],

                             0, handle);

              if (!gabble_handle_set_qdata (conn->handles,

                                            TP_HANDLE_TYPE_CONTACT,

                                            handle,

                                            gabble_vcard_manager_cache_quark(),

                                            alias, g_free))

                {

                  gabble_debug (DEBUG_FLAG, "failed to cache their alias");

                  g_free (alias);

                }

            }

          g_strfreev (bits);

        }

    }

  else

    {

      const gchar *fn = NULL;

      /* let's see if they have a FN (formatted name) instead */

      nick_node = lm_message_node_get_child (vcard_node, "FN");

      if (nick_node)

        fn = lm_message_node_get_value (nick_node);

      gabble_debug (DEBUG_FLAG, "%u has no <NICKNAME>, but has <FN> \"%s\"", handle,

             fn ? fn : "(null)");

      if (fn && *fn)

        {

          gchar *alias = g_strdup (fn);

          gabble_debug (DEBUG_FLAG, "... using \"%s\" as their alias", alias);

          g_signal_emit (G_OBJECT (manager), signals[NICKNAME_UPDATE],

                         0, handle);

          if (!gabble_handle_set_qdata (conn->handles,

                                        TP_HANDLE_TYPE_CONTACT,

                                        handle,

                                        gabble_vcard_manager_cache_quark(),

                                        alias, g_free))

            {

              gabble_debug (DEBUG_FLAG, "failed to cache their alias");

              g_free (alias);

            }

        }

      else

        {

          /* remember that they don't have an alias */

          if (!gabble_handle_set_qdata (conn->handles,

                                        TP_HANDLE_TYPE_CONTACT,

                                        handle,

                                        gabble_vcard_manager_cache_quark (),

                                        (gchar *) NO_ALIAS, NULL))

            gabble_debug (DEBUG_FLAG, "failed to cache their lack of vcard alias");

        }

    }

}

static GabbleVCardManagerRequest *request_send (GabbleVCardManagerRequest *,

                                                LmMessageNode *replacement,

                                                const gchar *jid,

                                                GError **);

static LmHandlerResult

replace_reply_cb (GabbleConnection *conn, LmMessage *sent_msg,

                  LmMessage *reply_msg, GObject *object, gpointer user_data)

{

  LmMessageNode *vcard_node = NULL;

  GError *err = NULL;

  GabbleVCardManagerRequest *request = (GabbleVCardManagerRequest*) user_data;

  GabbleVCardManager *manager = GABBLE_VCARD_MANAGER (object);

  GabbleVCardManagerPrivate *priv = GABBLE_VCARD_MANAGER_GET_PRIVATE (manager);

  g_assert (request);

  gabble_debug (DEBUG_FLAG, "Replace request got a reply: conn@%p, sent_msg@%p, reply_msg@%p, "

         "bound object@%p, request@%p", conn, sent_msg, reply_msg, object,

         user_data);

  if (!g_list_find (priv->requests, request))

    {

      gabble_debug (DEBUG_FLAG, "I don't care about that request any more");

      return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

    }