/* Copyright 2009,2010 Myhailo Danylenko

 *

 * Service discovery requests

 *

 * This file is part of mcabber-disco

 *

 * mcabber-disco 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, see <http://www.gnu.org/licenses/>. */

#include <glib.h>

#include <loudmouth/loudmouth.h>

#include <string.h>

#include <mcabber/commands.h>

#include <mcabber/logprint.h>

#include <mcabber/utils.h>

#include <mcabber/hooks.h>

#include <mcabber/xmpp.h>

#include <mcabber/compl.h>

#include <mcabber/xmpp_defines.h>

#include <mcabber/screen.h>

#include <mcabber/hbuf.h>

#include <mcabber/modules.h>

#include <mcabber/caps.h>

#include "disco.h"

#include "config.h"

//

// module description

//

static void disco_init   (void);

static void disco_uninit (void);

#define DESCRIPTION ( "Service discovery requests\nProvides command /disco" )

static module_info_t info_disco_experimental = {

	.branch      = "experimental",

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = disco_init,

	.uninit      = disco_uninit,

	.next        = NULL,

};

static module_info_t info_disco_dev = {

	.branch      = "dev",

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = disco_init,

	.uninit      = disco_uninit,

	.next        = &info_disco_experimental,

};

module_info_t info_disco_0_10_0 = {

	.branch      = "0.10.0",

	.api         = 1,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = disco_init,

	.uninit      = disco_uninit,

	.next        = &info_disco_dev,

};

module_info_t info_disco = {

	.branch      = "0.10.1",

	.api         = 1,

	.version     = PROJECT_VERSION,

	.description = DESCRIPTION,

	.requires    = NULL,

	.init        = disco_init,

	.uninit      = disco_uninit,

	.next        = &info_disco_0_10_0,

};

//

// private types

//

// lm message handler userdata

typedef struct {

	disco_info_handler_t handler;

	gpointer             data;

	GDestroyNotify       notify;

} disco_info_reply_handler_t;

// lm message handler userdata

typedef struct {

	disco_items_handler_t handler;

	gpointer              data;

	GDestroyNotify        notify;

} disco_items_reply_handler_t;

// user request disco handler userdata (common for info and items)

typedef struct {

	gchar *jid;

	gchar *node;

} disco_handler_t;

//

// globals

//

#ifdef HAVE_CMD_ID

static gpointer disco_cmid = NULL;

#endif

static guint   disco_cid      = 0;

static guint   disco_hid      = 0;

static GSList *reply_handlers = NULL;

//

// destroyers

//

static void disco_info_reply_handler_destroy_notify (gpointer data)

{

	disco_info_reply_handler_t *cb = data;

	if (cb -> notify)

		cb -> notify (cb -> data);

	g_free (cb);

	return;

}

static void disco_items_reply_handler_destroy_notify (gpointer data)

{

	disco_items_reply_handler_t *cb = data;

	if (cb -> notify)

		cb -> notify (cb -> data);

	g_free (cb);

	return;

}

static void disco_handler_destroy_notify (gpointer data)

{

	disco_handler_t *cb = data;

	g_free (cb -> jid);

	g_free (cb -> node);

	g_free (cb);

	return;

}

//

// lm reply handlers

//

static LmHandlerResult disco_info_reply_handler (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer udata)

{

	disco_info_reply_handler_t *cb = udata;

	reply_handlers = g_slist_remove (reply_handlers, handler);

	switch (lm_message_get_sub_type (message)) {

	case LM_MESSAGE_SUB_TYPE_RESULT:

		{

			LmMessageNode *node       = lm_message_get_node (message);

			GSList        *identities = NULL;

			GSList        *features   = NULL;

			node = lm_message_node_get_child (node, "query");

			// check xmlns

			if (!node || g_strcmp0 (lm_message_node_get_attribute (node, "xmlns"), NS_DISCO_INFO))

				break;

			// parse request results

			if (node->children)

				for (node = node->children; node; node = node->next)

					if (!strcasecmp (node->name, "identity")) {

						disco_identity_t *identity = g_new (disco_identity_t, 1);

						identity -> category = lm_message_node_get_attribute (node, "category");

						identity -> type     = lm_message_node_get_attribute (node, "type");

						identity -> name     = lm_message_node_get_attribute (node, "name");

						identity -> reserved = NULL;

						identities = g_slist_append (identities, identity);

					} else if (!strcasecmp (node->name, "feature"))

						features = g_slist_insert_sorted (features, (gpointer) lm_message_node_get_attribute (node, "var"), (GCompareFunc) g_strcmp0);

			// call handler

			cb -> handler (identities, features, cb -> data);

			{ // free resources

				GSList *iel;

				for (iel = identities; iel; iel = iel -> next)

					g_free (iel -> data);

				g_slist_free (identities);

				g_slist_free (features);

			}

		}

		break;

	case LM_MESSAGE_SUB_TYPE_ERROR:

		{

			LmMessageNode *node   = lm_message_get_node (message);

			const gchar   *from   = lm_message_node_get_attribute (node, "from");

			const gchar   *type;

			const gchar   *reason;

			node = lm_message_node_get_child (node, "error");

			type = lm_message_node_get_attribute (node, "type");

			if (node->children)

				reason = node->children->name;

			else

				reason = "undefined";

			// XXX: we need to inform user, but do we really need to print this on every possible error?

			scr_log_print (LPRINT_LOGNORM, "disco: Service info discovery for %s failed: %s - %s", from, type, reason);

			cb -> handler (NULL, NULL, cb -> data);

		}

		break;

	default:

		return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

	}

	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult disco_items_reply_handler (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer udata)

{

	disco_items_reply_handler_t *cb = udata;

	reply_handlers = g_slist_remove (reply_handlers, handler);

	switch (lm_message_get_sub_type (message)) {

	case LM_MESSAGE_SUB_TYPE_RESULT:

		{

			LmMessageNode *node  = lm_message_get_node (message);

			GSList        *items = NULL;

			node = lm_message_node_get_child (node, "query");

			// check xmlns

			if (!node || g_strcmp0 (lm_message_node_get_attribute (node, "xmlns"), NS_DISCO_ITEMS))

				break;

			// parse request results

			if (node->children)

				for (node = node->children; node; node = node->next)

					if (!strcasecmp (node->name, "item")) {

						disco_item_t *item = g_new (disco_item_t, 1);

						item -> name = lm_message_node_get_attribute (node, "name");

						item -> jid  = lm_message_node_get_attribute (node, "jid");

						item -> node = lm_message_node_get_attribute (node, "node");

						items = g_slist_append (items, item);

					}

			// call handler

			cb -> handler (items, cb -> data);

			{ // free resources

				GSList *iel;

				for (iel = items; iel; iel = iel -> next)

					g_free (iel -> data);

				g_slist_free (items);

			}

		}

		break;

	case LM_MESSAGE_SUB_TYPE_ERROR:

		{

			LmMessageNode *node   = lm_message_get_node (message);

			const gchar   *from   = lm_message_node_get_attribute (node, "from");

			const gchar   *type;

			const gchar   *reason;

			node = lm_message_node_get_child (node, "error");

			type = lm_message_node_get_attribute (node, "type");

			if (node->children)

				reason = node->children->name;

			else

				reason = "undefined";

			// XXX: we need to inform user, but do we really need to print this on every possible error?

			scr_log_print (LPRINT_LOGNORM, "disco: Service items discovery for %s failed: %s - %s", from, type, reason);

			cb -> handler (NULL, cb -> data);

		}

		break;

	default:

		return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

	}

	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

//

// disco requests sending

//

#if 0

static void disco_features_cb (gconstpointer data, gpointer userdata)

{

	const gchar  *feature  = data;

	GSList      **features = userdata;

	*features = g_slist_insert_sorted (*features, (gpointer) feature, (GCompareFunc) g_strcmp0);

	return;

}

#endif

gpointer disco_info_request (const gchar *jid, const gchar *dnode, disco_info_handler_t handler, gpointer userdata, GDestroyNotify notify)

{

	if (!handler || !xmpp_is_online ()) {

		if (notify)

			notify (userdata);

		return NULL;

	}

#if 0

	if (0 && !dnode) { // FIXME: no way to get identity(ies) from caps

		gchar       *bjid     = jidtodisp (jid);

		GSList      *buddy    = roster_find (bjid, jidsearch, ROSTER_TYPE_USER | ROSTER_TYPE_ROOM | ROSTER_TYPE_AGENT);

		const gchar *resource = strchr (jid, JID_RESOURCE_SEPARATOR);

		g_free (bjid);

		if (buddy) {

			const gchar *hash = buddy_resource_getcaps (BUDDATA(buddy), resource); // ?? will it all work?

			if (hash) { // cached result

				GSList *identities = NULL;

				GSList *features   = NULL;

				caps_foreach_feature (hash, disco_features_cb, &features);

				handler (identities, features, userdata);

				if (notify)

					notify (userdata);

				return NULL;

			}

		}

	}

#endif

	{ // send request

		LmMessage        *request;

		LmMessageNode    *node;

		LmMessageHandler *lhandler;

		GError           *error    = NULL;

		request = lm_message_new_with_sub_type (jid, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);

		node    = lm_message_get_node (request);

		node    = lm_message_node_add_child (node, "query", NULL);

		lm_message_node_set_attribute (node, "xmlns", NS_DISCO_INFO);

		if (dnode)

			lm_message_node_set_attribute (node, "node", dnode);

		{

			disco_info_reply_handler_t *cb = g_new (disco_info_reply_handler_t, 1);

			lhandler = lm_message_handler_new (disco_info_reply_handler, cb, disco_info_reply_handler_destroy_notify);

			cb -> handler = handler;

			cb -> data    = userdata;

			cb -> notify  = notify;

			reply_handlers = g_slist_append (reply_handlers, lhandler);

			lm_connection_send_with_reply (lconnection, request, lhandler, &error);

			if (error) {

				// XXX destroy handler and return NULL?

				scr_log_print (LPRINT_DEBUG, "disco: Error sending disco request: %s.", error -> message);

				g_error_free (error);

			}

			lm_message_handler_unref (lhandler);

		}

		lm_message_unref (request);

		return lhandler;