/*

 * gabble-roomlist-channel.c - Source for GabbleRoomlistChannel

 * Copyright (C) 2005 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 <stdio.h>

#include <stdlib.h>

#include <string.h>

#define DEBUG_FLAG GABBLE_DEBUG_ROOMLIST

#include "debug.h"

#include "disco.h"

#include "gabble-connection.h"

#include "handles.h"

#include "handle-set.h"

#include "telepathy-constants.h"

#include "telepathy-interfaces.h"

#include "telepathy-helpers.h"

#include "tp-channel-iface.h"

#include "namespaces.h"

#include "util.h"

#include "gabble-roomlist-channel.h"

#include "gabble-roomlist-channel-glue.h"

#include "gabble-roomlist-channel-signals-marshal.h"

#include "gabble_enums.h"

#define TP_TYPE_ROOM_STRUCT (dbus_g_type_get_struct ("GValueArray", \

      G_TYPE_UINT, \

      G_TYPE_STRING, \

      dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), \

      G_TYPE_INVALID))

#define TP_TYPE_ROOM_LIST (dbus_g_type_get_collection ("GPtrArray", \

      TP_TYPE_ROOM_STRUCT))

#ifndef EMULATOR

G_DEFINE_TYPE_WITH_CODE (GabbleRoomlistChannel, gabble_roomlist_channel,

    G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));

#endif

/* signal enum */

enum

{

    CLOSED,

    GOT_ROOMS,

    LISTING_ROOMS,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_ROOM_CHNL

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_room_chnl,guint)

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

	GET_STATIC_VAR_FROM_TLS(gabble_roomlist_channel_parent_class,gabble_room_chnl,gpointer)

	#define gabble_roomlist_channel_parent_class (*GET_WSD_VAR_NAME(gabble_roomlist_channel_parent_class,gabble_room_chnl,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_room_chnl,GType)

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

	static void gabble_roomlist_channel_init (GabbleRoomlistChannel *self);

	 static void gabble_roomlist_channel_class_init (GabbleRoomlistChannelClass *klass); 

	 static void gabble_roomlist_channel_class_intern_init (gpointer klass) 

	 {

	  gabble_roomlist_channel_parent_class = g_type_class_peek_parent (klass); 

	  gabble_roomlist_channel_class_init ((GabbleRoomlistChannelClass*) klass);

	   } 

	   EXPORT_C GType gabble_roomlist_channel_get_type (void) 

	   {

	   if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleRoomlistChannelClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_roomlist_channel_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleRoomlistChannel), 0, (GInstanceInitFunc) gabble_roomlist_channel_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleRoomlistChannel"), &g_define_type_info, (GTypeFlags) 0); { { static const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc) ((void *)0) }; g_type_add_interface_static (g_define_type_id, tp_channel_iface_get_type(), &g_implement_interface_info); } ; } } return g_define_type_id; }    ;

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif

/* properties */

enum

{

  PROP_OBJECT_PATH = 1,

  PROP_CHANNEL_TYPE,

  PROP_HANDLE_TYPE,

  PROP_HANDLE,

  PROP_CONNECTION,

  PROP_CONFERENCE_SERVER,

  LAST_PROPERTY

};

/* private structure */

typedef struct _GabbleRoomlistChannelPrivate GabbleRoomlistChannelPrivate;

struct _GabbleRoomlistChannelPrivate

{

  GabbleConnection *conn;

  gchar *object_path;

  gchar *conference_server;

  gboolean closed;

  gboolean listing;

  gpointer disco_pipeline;

  GabbleHandleSet *signalled_rooms;

  GPtrArray *pending_room_signals;

  guint timer_source_id;

  gboolean dispose_has_run;

};

#define GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE(obj) \

    ((GabbleRoomlistChannelPrivate *)obj->priv)

#define ROOM_SIGNAL_INTERVAL 300

static gboolean emit_room_signal (gpointer data);

static void

gabble_roomlist_channel_init (GabbleRoomlistChannel *self)

{

  GabbleRoomlistChannelPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_ROOMLIST_CHANNEL, GabbleRoomlistChannelPrivate);

  self->priv = priv;

  priv->pending_room_signals = g_ptr_array_new ();

}

static GObject *

gabble_roomlist_channel_constructor (GType type, guint n_props,

                               GObjectConstructParam *props)

{

  GObject *obj;

  GabbleRoomlistChannelPrivate *priv;

  DBusGConnection *bus;

  obj = G_OBJECT_CLASS (gabble_roomlist_channel_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (GABBLE_ROOMLIST_CHANNEL (obj));

  bus = tp_get_bus ();

  dbus_g_connection_register_g_object (bus, priv->object_path, obj);

  return obj;

}

static void

gabble_roomlist_channel_get_property (GObject    *object,

                                guint       property_id,

                                GValue     *value,

                                GParamSpec *pspec)

{

  GabbleRoomlistChannel *chan = GABBLE_ROOMLIST_CHANNEL (object);

  GabbleRoomlistChannelPrivate *priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (chan);

  switch (property_id) {

    case PROP_OBJECT_PATH:

      g_value_set_string (value, priv->object_path);

      break;

    case PROP_CHANNEL_TYPE:

      g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_ROOM_LIST);

      break;

    case PROP_HANDLE_TYPE:

      g_value_set_uint (value, TP_HANDLE_TYPE_NONE);

      break;

    case PROP_HANDLE:

      g_value_set_uint (value, 0);

      break;

    case PROP_CONNECTION:

      g_value_set_object (value, priv->conn);

      break;

    case PROP_CONFERENCE_SERVER:

      g_value_set_string (value, priv->conference_server);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_roomlist_channel_set_property (GObject     *object,

                                guint        property_id,

                                const GValue *value,

                                GParamSpec   *pspec)

{

  GabbleRoomlistChannel *chan = GABBLE_ROOMLIST_CHANNEL (object);

  GabbleRoomlistChannelPrivate *priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (chan);

  GabbleHandleSet *new_signalled_rooms;

  switch (property_id) {

    case PROP_OBJECT_PATH:

      g_free (priv->object_path);

      priv->object_path = g_value_dup_string (value);

      break;

    case PROP_HANDLE:

      /* this property is writable in the interface, but not actually

       * meaningfully changable on this channel, so we do nothing */

      break;

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      new_signalled_rooms = handle_set_new (priv->conn->handles, TP_HANDLE_TYPE_ROOM);

      if (priv->signalled_rooms != NULL)

        {

          const GIntSet *add;

          GIntSet *tmp;

          add = handle_set_peek (priv->signalled_rooms);

          tmp = handle_set_update (new_signalled_rooms, add);

          handle_set_destroy (priv->signalled_rooms);

          g_intset_destroy (tmp);

        }

      priv->signalled_rooms = new_signalled_rooms;

      break;

    case PROP_CONFERENCE_SERVER:

      g_free (priv->conference_server);

      priv->conference_server = g_value_dup_string (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void gabble_roomlist_channel_dispose (GObject *object);

static void gabble_roomlist_channel_finalize (GObject *object);

static void

gabble_roomlist_channel_class_init (GabbleRoomlistChannelClass *gabble_roomlist_channel_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_roomlist_channel_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_roomlist_channel_class, sizeof (GabbleRoomlistChannelPrivate));

  object_class->constructor = gabble_roomlist_channel_constructor;

  object_class->get_property = gabble_roomlist_channel_get_property;

  object_class->set_property = gabble_roomlist_channel_set_property;

  object_class->dispose = gabble_roomlist_channel_dispose;

  object_class->finalize = gabble_roomlist_channel_finalize;

  g_object_class_override_property (object_class, PROP_OBJECT_PATH, "object-path");

  g_object_class_override_property (object_class, PROP_CHANNEL_TYPE, "channel-type");

  g_object_class_override_property (object_class, PROP_HANDLE_TYPE, "handle-type");

  g_object_class_override_property (object_class, PROP_HANDLE, "handle");

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

                                    "Gabble connection object that owns this "

                                    "room list channel 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);

  param_spec = g_param_spec_string ("conference-server",

                                    "Name of conference server to use",

                                    "Name of the XMPP conference server "

                                    "on which to list rooms",

                                    "",

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_WRITABLE |

                                    G_PARAM_STATIC_NAME |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_CONFERENCE_SERVER,

                                   param_spec);

  signals[CLOSED] =

    g_signal_new ("closed",

                  G_OBJECT_CLASS_TYPE (gabble_roomlist_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__VOID,

                  G_TYPE_NONE, 0);

  signals[GOT_ROOMS] =

    g_signal_new ("got-rooms",

                  G_OBJECT_CLASS_TYPE (gabble_roomlist_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__BOXED,

                  G_TYPE_NONE, 1, (dbus_g_type_get_collection ("GPtrArray", (dbus_g_type_get_struct ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, (dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE)), G_TYPE_INVALID)))));

  signals[LISTING_ROOMS] =

    g_signal_new ("listing-rooms",

                  G_OBJECT_CLASS_TYPE (gabble_roomlist_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__BOOLEAN,

                  G_TYPE_NONE, 1, G_TYPE_BOOLEAN);

  dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_roomlist_channel_class), &dbus_glib_gabble_roomlist_channel_object_info);

}

void

gabble_roomlist_channel_dispose (GObject *object)

{

  GabbleRoomlistChannel *self = GABBLE_ROOMLIST_CHANNEL (object);

  GabbleRoomlistChannelPrivate *priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (self);

  if (priv->dispose_has_run)

    return;

  priv->dispose_has_run = TRUE;

  if (priv->listing)

    {

      emit_room_signal (object);

      g_signal_emit (object, signals [LISTING_ROOMS], 0, FALSE);

      priv->listing = FALSE;

    }

  if (!priv->closed)

    {

      g_signal_emit (object, signals[CLOSED], 0);

      priv->closed = TRUE;

    }

  if (priv->disco_pipeline != NULL)

    {

      gabble_disco_pipeline_destroy (priv->disco_pipeline);

      priv->disco_pipeline = NULL;

    }

  if (priv->timer_source_id)

    {

      g_source_remove (priv->timer_source_id);

      priv->timer_source_id = 0;

    }

  g_assert (priv->pending_room_signals != NULL);

  g_assert (priv->pending_room_signals->len == 0);

  g_ptr_array_free (priv->pending_room_signals, TRUE);

  priv->pending_room_signals = NULL;

  if (G_OBJECT_CLASS (gabble_roomlist_channel_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_roomlist_channel_parent_class)->dispose (object);

}

void

gabble_roomlist_channel_finalize (GObject *object)

{

  GabbleRoomlistChannel *self = GABBLE_ROOMLIST_CHANNEL (object);

  GabbleRoomlistChannelPrivate *priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (self);

  /* free any data held directly by the object here */

  g_free (priv->object_path);

  g_free (priv->conference_server);

  if (priv->signalled_rooms != NULL)

    handle_set_destroy (priv->signalled_rooms);

  G_OBJECT_CLASS (gabble_roomlist_channel_parent_class)->finalize (object);

}

GabbleRoomlistChannel *

_gabble_roomlist_channel_new (GabbleConnection *conn,

                              const gchar *object_path,

                              const gchar *conference_server)

{

  g_return_val_if_fail (GABBLE_IS_CONNECTION (conn), NULL);

  g_return_val_if_fail (object_path != NULL, NULL);

  g_return_val_if_fail (conference_server != NULL, NULL);

  return GABBLE_ROOMLIST_CHANNEL (

      g_object_new (GABBLE_TYPE_ROOMLIST_CHANNEL,

                    "connection", conn,

                    "object-path", object_path,

                    "conference-server", conference_server, NULL));

}

static gboolean

emit_room_signal (gpointer data)

{

  GabbleRoomlistChannel *chan = data;

  GabbleRoomlistChannelPrivate *priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (chan);

  if (!priv->listing)

      return FALSE;

  if (priv->pending_room_signals->len == 0)

      return TRUE;

  g_signal_emit (chan, signals[GOT_ROOMS], 0, priv->pending_room_signals);

  while (priv->pending_room_signals->len != 0)

    {

      gpointer boxed = g_ptr_array_index (priv->pending_room_signals, 0);

      g_boxed_free (TP_TYPE_ROOM_STRUCT, boxed);

      g_ptr_array_remove_index_fast (priv->pending_room_signals, 0);

    }

  return TRUE;

}

/**

 * destroy_value:

 * @data: a GValue to destroy

 *

 * destroys a GValue allocated on the heap

 */

static void

destroy_value (GValue *value)

{

  g_value_unset (value);

  g_free (value);

}

static void

room_info_cb (gpointer pipeline, GabbleDiscoItem *item, gpointer user_data)

{

  GabbleRoomlistChannel *chan = user_data;

  GabbleRoomlistChannelPrivate *priv;

  const char *jid, *category, *type, *var, *name;

  GabbleHandle handle;

  GHashTable *keys;

  GValue room = {0,};

  GValue *tmp;

  gpointer k, v;

  #define INSERT_KEY(hash, name, type, type2, value) \

    do {\

      tmp = g_new0 (GValue, 1); \

      g_value_init (tmp, (type)); \

      g_value_set_##type2 (tmp, (value)); \

      g_hash_table_insert (hash, (name), tmp); \

    } while (0)

  g_assert (GABBLE_IS_ROOMLIST_CHANNEL (chan));

  priv = GABBLE_ROOMLIST_CHANNEL_GET_PRIVATE (chan);

  jid = item->jid;

  name = item->name;

  category = item->category;

  type = item->type;

  if (0 != strcmp (category, "conference") ||

      0 != strcmp (type, "text"))

    return;

  if (!g_hash_table_lookup_extended (item->features, "http://jabber.org/protocol/muc", &k, &v))

    {

      /* not muc */

      return;

    }

  gabble_debug (DEBUG_FLAG, "got room identity, name=%s, category=%s, type=%s", name, category, type);

  keys = g_hash_table_new_full (g_str_hash, g_str_equal, NULL,

                                (GDestroyNotify) destroy_value);

  INSERT_KEY (keys, "name", G_TYPE_STRING, string, name);

  if (g_hash_table_lookup_extended (item->features, "muc_membersonly", &k, &v))

    INSERT_KEY (keys, "invite-only", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_open", &k, &v))

    INSERT_KEY (keys, "invite-only", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_passwordprotected", &k, &v))

    INSERT_KEY (keys, "password", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_unsecure", &k, &v))

    INSERT_KEY (keys, "password", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_unsecured", &k, &v))

    INSERT_KEY (keys, "password", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_hidden", &k, &v))

    INSERT_KEY (keys, "hidden", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_public", &k, &v))

    INSERT_KEY (keys, "hidden", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_membersonly", &k, &v))

    INSERT_KEY (keys, "members-only", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_open", &k, &v))

    INSERT_KEY (keys, "members-only", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_moderated", &k, &v))

    INSERT_KEY (keys, "moderated", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_unmoderated", &k, &v))

    INSERT_KEY (keys, "moderated", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_nonanonymous", &k, &v))

    INSERT_KEY (keys, "anonymous", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_anonymous", &k, &v))

    INSERT_KEY (keys, "anonymous", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_semianonymous", &k, &v))

    INSERT_KEY (keys, "anonymous", G_TYPE_BOOLEAN, boolean, FALSE);

  if (g_hash_table_lookup_extended (item->features, "muc_persistent", &k, &v))

    INSERT_KEY (keys, "persistent", G_TYPE_BOOLEAN, boolean, TRUE);

  if (g_hash_table_lookup_extended (item->features, "muc_temporary", &k, &v))

    INSERT_KEY (keys, "persistent", G_TYPE_BOOLEAN, boolean, FALSE);

  var = g_hash_table_lookup (item->features, "muc#roominfo_description");

  if (var != NULL)

    INSERT_KEY (keys, "description", G_TYPE_STRING, string, var);

  var = g_hash_table_lookup (item->features, "muc#roominfo_occupants");

  if (var != NULL)

    INSERT_KEY (keys, "members", G_TYPE_UINT, uint,

                (guint) g_ascii_strtoull (var, NULL, 10));