/*

 * gabble-media-stream-glue.h

 *

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

#include <string.h>

#include "loudmouth/loudmouth.h"

#include "debug.h"

#include "disco.h"

#include "gabble-connection.h"

#include "gabble-error.h"

#include "namespaces.h"

#include "telepathy-helpers.h"

#include "util.h"

#include "search-keys-info.h"

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_VAR_FROM_TLS(quark,gabble_disco,GQuark)

	#define quark (*GET_WSD_VAR_NAME(quark,gabble_disco,s)())

	GET_STATIC_VAR_FROM_TLS(gabble_disco_parent_class,gabble_disco,gpointer)

	#define gabble_disco_parent_class (*GET_WSD_VAR_NAME(gabble_disco_parent_class,gabble_disco,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_disco,GType)

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

static void gabble_disco_init (GabbleDisco *self); 

static void gabble_disco_class_init (GabbleDiscoClass *klass); 

static void gabble_disco_class_intern_init (gpointer klass) 

{ 

gabble_disco_parent_class = g_type_class_peek_parent (klass); 

gabble_disco_class_init ((GabbleDiscoClass*) klass); 

} 

EXPORT_C GType gabble_disco_get_type (void) 

{ 

if ((g_define_type_id == 0)) 

{ 

static const GTypeInfo g_define_type_info = 

	{ sizeof (GabbleDiscoClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_disco_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleDisco), 0, (GInstanceInitFunc) gabble_disco_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleDisco"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

	} ;

#endif

#define DBUS_API_SUBJECT_TO_CHANGE

#define DEBUG_FLAG GABBLE_DEBUG_DISCO

#define DEFAULT_REQUEST_TIMEOUT 20000

#define DISCO_PIPELINE_SIZE 10

/* Properties */

enum

{

  PROP_CONNECTION = 1,

  LAST_PROPERTY

};

#ifndef EMULATOR

G_DEFINE_TYPE(GabbleDisco, gabble_disco, G_TYPE_OBJECT);

#endif

typedef struct _GabbleDiscoPrivate GabbleDiscoPrivate;

struct _GabbleDiscoPrivate

{

  GabbleConnection *connection;

  GSList *service_cache;

  GList *requests;

  gboolean dispose_has_run;

};

struct _GabbleDiscoRequest

{

  GabbleDisco *disco;

  guint timer_id;

  GabbleDiscoType type;

  gchar *jid;

  gchar *node;

  GabbleDiscoCb callback;

  gpointer user_data;

  GObject *bound_object;

};

GQuark

gabble_disco_error_quark (void)

{

#ifndef EMULATOR

  static GQuark quark = 0;

#endif

  if (!quark)

    quark = g_quark_from_static_string ("gabble-disco-error");

  return quark;

}

#define GABBLE_DISCO_GET_PRIVATE(o)     ((GabbleDiscoPrivate*)((o)->priv));

static void

gabble_disco_init (GabbleDisco *obj)

{

  GabbleDiscoPrivate *priv =

     G_TYPE_INSTANCE_GET_PRIVATE (obj, GABBLE_TYPE_DISCO, GabbleDiscoPrivate);

  obj->priv = priv;

}

static GObject *gabble_disco_constructor (GType type, guint n_props,

    GObjectConstructParam *props);

static void gabble_disco_set_property (GObject *object, guint property_id,

    const GValue *value, GParamSpec *pspec);

static void gabble_disco_get_property (GObject *object, guint property_id,

    GValue *value, GParamSpec *pspec);

static void gabble_disco_dispose (GObject *object);

static void gabble_disco_finalize (GObject *object);

static void

gabble_disco_class_init (GabbleDiscoClass *gabble_disco_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_disco_class);

  GParamSpec *param_spec;  

  g_type_class_add_private (gabble_disco_class, sizeof (GabbleDiscoPrivate));

  object_class->constructor = gabble_disco_constructor;

  object_class->get_property = gabble_disco_get_property;

  object_class->set_property = gabble_disco_set_property;

  object_class->dispose = gabble_disco_dispose;

  object_class->finalize = gabble_disco_finalize;

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

                                    "Gabble connection object that owns this "

                                    "XMPP Discovery 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);

}

static void

gabble_disco_get_property (GObject    *object,

                                guint       property_id,

                                GValue     *value,

                                GParamSpec *pspec)

{

  GabbleDisco *chan = GABBLE_DISCO (object);

  GabbleDiscoPrivate *priv = GABBLE_DISCO_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_disco_set_property (GObject     *object,

                           guint        property_id,

                           const GValue *value,

                           GParamSpec   *pspec)

{

  GabbleDisco *chan = GABBLE_DISCO (object);

  GabbleDiscoPrivate *priv = GABBLE_DISCO_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 gabble_disco_conn_status_changed_cb (GabbleConnection *conn,

    TpConnectionStatus status, TpConnectionStatusReason reason, gpointer data);

static GObject *

gabble_disco_constructor (GType type, guint n_props,

                          GObjectConstructParam *props)

{

  GObject *obj;

  GabbleDisco *disco;

  GabbleDiscoPrivate *priv;

  obj = G_OBJECT_CLASS (gabble_disco_parent_class)-> constructor (type,

      n_props, props);

  disco = GABBLE_DISCO (obj);

  priv = GABBLE_DISCO_GET_PRIVATE (disco);

  g_signal_connect (priv->connection, "status-changed",

      G_CALLBACK (gabble_disco_conn_status_changed_cb), disco);

  return obj;

}

static void cancel_request (GabbleDiscoRequest *request);

void

gabble_disco_dispose (GObject *object)

{

  GSList *l;

  DBusGProxy *bus_proxy;

  GabbleDisco *self = GABBLE_DISCO (object);

  GabbleDiscoPrivate *priv = GABBLE_DISCO_GET_PRIVATE (self);

  bus_proxy = tp_get_bus_proxy ();

  if (priv->dispose_has_run)

    return;

  priv->dispose_has_run = TRUE;

  gabble_debug (DEBUG_FLAG, "dispose called");

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

  while (priv->requests)

    cancel_request (priv->requests->data);

  for (l = priv->service_cache; l; l = g_slist_next (l))

    {

      GabbleDiscoItem *item = (GabbleDiscoItem *) l->data;

      g_free ((char *) item->jid);

      g_free ((char *) item->name);

      g_free ((char *) item->type);

      g_free ((char *) item->category);

      g_hash_table_destroy (item->features);

      g_free (item);

    }

  g_slist_free (priv->service_cache);

  priv->service_cache = NULL;

  if (G_OBJECT_CLASS (gabble_disco_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_disco_parent_class)->dispose (object);

}

void

gabble_disco_finalize (GObject *object)

{

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

  G_OBJECT_CLASS (gabble_disco_parent_class)->finalize (object);

}

/**

 * gabble_disco_new:

 * @conn: The #GabbleConnection to use for service discovery

 *

 * Creates an object to use for Jabber service discovery (DISCO)

 * There should be one of these per connection

 */

GabbleDisco *

gabble_disco_new (GabbleConnection *conn)

{

  GabbleDisco *disco;

  g_return_val_if_fail (GABBLE_IS_CONNECTION (conn), NULL);

  disco = GABBLE_DISCO (g_object_new (GABBLE_TYPE_DISCO,

        "connection", conn,

        NULL));

  return disco;

}

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

static void

delete_request (GabbleDiscoRequest *request)

{

  GabbleDisco *disco = request->disco;

  GabbleDiscoPrivate *priv;

  g_assert (NULL != request);

    /* fix: Application Crashed: Main */

  if ( disco == NULL )

      {

      g_debug ("%s: accesing after dereferenced connection", G_STRFUNC);

      return;

      }

  g_assert (GABBLE_IS_DISCO (disco));

  priv = GABBLE_DISCO_GET_PRIVATE (disco);

  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);

    }

  g_free (request->jid);

  g_free (request);

}

static gboolean

timeout_request (gpointer data)

{

  GabbleDiscoRequest *request = (GabbleDiscoRequest*) data;

  GError *err;

  g_return_val_if_fail (data != NULL, FALSE);

  err = g_error_new (GABBLE_DISCO_ERROR, GABBLE_DISCO_ERROR_TIMEOUT,

      "Request for %s on %s timed out",

      (request->type == GABBLE_DISCO_TYPE_INFO)?"info":"items",

      request->jid);

  (request->callback)(request->disco, request, request->jid, request->node,

                      NULL, err, request->user_data);

  g_error_free (err);

  request->timer_id = 0;

  delete_request (request);

  return FALSE;

}

static void

cancel_request (GabbleDiscoRequest *request)

{

  GError *err;

  g_assert (request != NULL);

  err = g_error_new (GABBLE_DISCO_ERROR, GABBLE_DISCO_ERROR_CANCELLED,

      "Request for %s on %s cancelled",

      (request->type == GABBLE_DISCO_TYPE_INFO)?"info":"items",

      request->jid);

  (request->callback)(request->disco, request, request->jid, request->node,

                      NULL, err, request->user_data);

  g_error_free (err);

  delete_request (request);

}

static LmHandlerResult

request_reply_cb (GabbleConnection *conn, LmMessage *sent_msg,

                  LmMessage *reply_msg, GObject *object, gpointer user_data)

{

  LmMessageNode *query_node;

  GError *err = NULL;

  GabbleDiscoRequest *request = (GabbleDiscoRequest*) user_data;

  GabbleDisco *disco = GABBLE_DISCO (object);

  GabbleDiscoPrivate *priv = GABBLE_DISCO_GET_PRIVATE (disco);

  g_assert (request);

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

    return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

  query_node = lm_message_node_get_child (reply_msg->node, "query");

  if (lm_message_get_sub_type (reply_msg) == LM_MESSAGE_SUB_TYPE_ERROR)

    {

      LmMessageNode *error_node;

      error_node = lm_message_node_get_child (reply_msg->node, "error");

      if (error_node)

        {

          err = gabble_xmpp_error_to_g_error (

              gabble_xmpp_error_from_node (error_node));

        }

      if (err == NULL)

        {

          err = g_error_new (GABBLE_DISCO_ERROR,

                             GABBLE_DISCO_ERROR_UNKNOWN,

                             "an unknown error occurred");

        }

    }

  else if (NULL == query_node)

    {

      err = g_error_new (GABBLE_DISCO_ERROR, GABBLE_DISCO_ERROR_UNKNOWN,

          "disco response contained no <query> node");

    }

  request->callback (request->disco, request, request->jid, request->node,

                     query_node, err, request->user_data);

  delete_request (request);

  if (err)

    g_error_free (err);

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static void

notify_delete_request (gpointer data, GObject *obj)

{

  GabbleDiscoRequest *request = (GabbleDiscoRequest *) data;

  request->bound_object = NULL;

  delete_request (request);

}

/**

 * gabble_disco_request:

 * @self: #GabbleDisco object to use for request

 * @type: type of request

 * @jid: Jabber ID to request on

 * @node: node to request on @jid, or NULL

 * @callback: #GabbleDiscoCb to call on request fullfilment

 * @object: GObject to bind request to. the callback will not be

 *          called if this object has been unrefed. NULL if not needed

 * @error: #GError to return a telepathy error in if unable to make

 *         request, NULL if unneeded.

 *

 * Make a disco request on the given jid with the default timeout.

 */

GabbleDiscoRequest *

gabble_disco_request (GabbleDisco *self, GabbleDiscoType type,

                      const gchar *jid, const char *node,

                      GabbleDiscoCb callback, gpointer user_data,

                      GObject *object, GError **error)

{

  return gabble_disco_request_with_timeout (self, type, jid, node,

                                            DEFAULT_REQUEST_TIMEOUT,

                                            callback, user_data,

                                            object, error);

}

/**

 * gabble_disco_request_with_timeout:

 * @self: #GabbleDisco object to use for request

 * @type: type of request

 * @jid: Jabber ID to request on

 * @node: node to request on @jid, or NULL

 * @timeout: the time until the request fails, in milliseconds (1/1000ths of a second)

 * @callback: #GabbleDiscoCb to call on request fullfilment

 * @object: GObject to bind request to. the callback will not be

 *          called if this object has been unrefed. NULL if not needed

 * @error: #GError to return a telepathy error in if unable to make

 *         request, NULL if unneeded.

 *

 * Make a disco request on the given jid, which will fail unless a reply

 * is received within the given timeout interval.

 */

GabbleDiscoRequest *

gabble_disco_request_with_timeout (GabbleDisco *self, GabbleDiscoType type,

                                   const gchar *jid, const char *node,

                                   guint timeout, GabbleDiscoCb callback,

                                   gpointer user_data, GObject *object,

                                   GError **error)

{

  const gchar *xmlns;

  LmMessage *msg;

  LmMessageNode *lm_node;

  GabbleDiscoRequest *request;

  GabbleDiscoPrivate *priv = GABBLE_DISCO_GET_PRIVATE (self);

  request = g_new0 (GabbleDiscoRequest, 1);

  request->disco = self;

  request->type = type;

  request->jid = g_strdup (jid);

  if (node)

    request->node = g_strdup (node);

  request->callback = callback;

  request->user_data = user_data;

  request->bound_object = object;

  if (NULL != object)

    g_object_weak_ref (object, notify_delete_request, request);

  gabble_debug (DEBUG_FLAG, "Creating disco request %p for %s",

           request, request->jid);

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

  msg = lm_message_new_with_sub_type (jid, LM_MESSAGE_TYPE_IQ,

                                           LM_MESSAGE_SUB_TYPE_GET);

  lm_node = lm_message_node_add_child (msg->node, "query", NULL);

  switch (type) {

    case GABBLE_DISCO_TYPE_INFO:

      xmlns = NS_DISCO_INFO;

      break;