/*
 * jingle-info.c - Source for Jingle info discovery
 * Copyright (C) 2006 Collabora Ltd.
 * Portions  and/or its subsidiary/subsidiaries.All rights reserved.
 *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>
 *
 * 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 <string.h>
#include <stdlib.h>

#define DEBUG_FLAG GABBLE_DEBUG_MEDIA

#include "debug.h"
#include "jingle-info.h"
#include "gabble-error.h"
#include "namespaces.h"
#include "util.h"

#ifdef DEBUG_FLAG
//#define DEBUG(format, ...)
#define DEBUGGING 0
#define NODE_DEBUG(n, s)
#endif /* DEBUG_FLAG */

/**
 * jingle_info_discover_servers:
 *
 * Discover available Jingle servers.
 *
 * @conn: The GabbleConnection# object initiating the discovery.
 */
void
jingle_info_discover_servers (GabbleConnection *conn)
{
  LmMessage *msg = NULL;
  LmMessageNode *node;
  GError *error = NULL;
  GabbleHandle handle = conn->self_handle;
  const gchar *jid = gabble_handle_inspect (conn->handles, TP_HANDLE_TYPE_CONTACT, handle);

  msg = lm_message_new_with_sub_type (jid, LM_MESSAGE_TYPE_IQ,
                                      LM_MESSAGE_SUB_TYPE_GET);

  node = lm_message_node_add_child (msg->node, "query", NULL);
  lm_message_node_set_attribute (node, "xmlns", NS_GOOGLE_JINGLE_INFO);

  if (!_gabble_connection_send (conn, msg, &error))
    {
      g_warning ("%s: send failed: %s\n", G_STRFUNC, error->message);
      goto OUT;
    }

OUT:
  if (msg)
    lm_message_unref (msg);

  if (error)
    g_error_free (error);
}


/**
 * jingle_info_iq_callback
 *
 * Called by loudmouth when we get an incoming <iq>. This handler
 * is concerned only with Jingle info queries.
 */
LmHandlerResult
jingle_info_iq_callback (LmMessageHandler *handler,
                         LmConnection *lmconn,
                         LmMessage *message,
                         gpointer user_data)
{
  GabbleConnection *conn = GABBLE_CONNECTION (user_data);
  LmMessageSubType sub_type;
  LmMessageNode *query_node, *parent_node, *node;
  const gchar *str;
  guint port;

  if ( NULL == conn )
        {
        g_debug ("%s: accesing after dereferenced connection", G_STRFUNC);
        return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
        }
  
  query_node = lm_message_node_get_child_with_namespace (message->node,
      "query", NS_GOOGLE_JINGLE_INFO);

  if (query_node == NULL)
    return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

  NODE_DEBUG (message->node, "got");

  sub_type = lm_message_get_sub_type (message);

  if (sub_type == LM_MESSAGE_SUB_TYPE_RESULT ||
      sub_type == LM_MESSAGE_SUB_TYPE_SET)
    {
      parent_node = lm_message_node_get_child (query_node, "stun");
      if (parent_node)
        {
          for (node = parent_node->children; node; node = node->next)
            {
              if (strcmp (node->name, "server") == 0)
                {
                  str = lm_message_node_get_attribute (node, "host");
                  if (str)
                    {
                      gabble_debug (DEBUG_FLAG, "setting 'stun-server' to '%s'", str);

                      g_object_set (conn, "stun-server", str, NULL);
                    }

                  str = lm_message_node_get_attribute (node, "udp");
                  if (str)
                    {
                      port = atoi (str);

                      gabble_debug (DEBUG_FLAG, "setting 'stun-port' to %d", port);

                      g_object_set (conn, "stun-port", port, NULL);
                    }

                  /* only grab the first one for now */
                  break;
                }
            }
        }

      parent_node = lm_message_node_get_child (query_node, "relay");
      if (parent_node)
        {
          gboolean found_server = FALSE;

          for (node = parent_node->children; node; node = node->next)
            {
              if (!found_server && strcmp (node->name, "server") == 0)
                {
                  str = lm_message_node_get_attribute (node, "host");
                  if (str)
                    {
                      gabble_debug (DEBUG_FLAG, "setting 'stun-relay-server' to '%s'",
                               str);

                      g_object_set (conn, "stun-relay-server", str, NULL);
                    }

                  str = lm_message_node_get_attribute (node, "udp");
                  if (str)
                    {
                      port = atoi (str);

                      gabble_debug (DEBUG_FLAG, "setting 'stun-relay-udp-port' to %d",
                               port);

                      g_object_set (conn, "stun-relay-udp-port", port, NULL);
                    }

                  str = lm_message_node_get_attribute (node, "tcp");
                  if (str)
                    {
                      port = atoi (str);

                      gabble_debug (DEBUG_FLAG, "setting 'stun-relay-tcp-port' to %d",
                               port);

                      g_object_set (conn, "stun-relay-tcp-port", port, NULL);
                    }

                  str = lm_message_node_get_attribute (node, "tcpssl");
                  if (str)
                    {
                      port = atoi (str);

                      gabble_debug (DEBUG_FLAG, "setting 'stun-relay-ssltcp-port' to %d",
                               port);

                      g_object_set (conn, "stun-relay-ssltcp-port", port, NULL);
                    }

                  found_server = TRUE;
                }
              else if (strcmp (node->name, "token") == 0)
                {
                  str = lm_message_node_get_value (node);
                  if (str)
                    {
                      gabble_debug (DEBUG_FLAG, "setting 'stun-relay-magic-cookie' to '%s'",
                               str);

                      g_object_set (conn, "stun-relay-magic-cookie", str, NULL);
                    }
                }
            }
        }

      if (sub_type == LM_MESSAGE_SUB_TYPE_SET)
        {
          _gabble_connection_acknowledge_set_iq (conn, message);
        }
    }
  else if (sub_type == LM_MESSAGE_SUB_TYPE_ERROR)
    {
      GabbleXmppError xmpp_error = INVALID_XMPP_ERROR;

      node = lm_message_node_get_child (message->node, "error");
      if (node)
        {
          xmpp_error = gabble_xmpp_error_from_node (node);
        }

      str = gabble_xmpp_error_string (xmpp_error);

      g_warning ("%s: jingle info error: %s", G_STRFUNC,
          (str) ? str : "unknown error");
    }
  else
    {
      NODE_DEBUG (message->node, "unknown message sub type");
    }

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}