/*

 * gabble-muc-channel.c - Source for GabbleMucChannel

 * Copyright (C) 2006 Collabora Ltd.

 * 

 *   @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 <dbus/dbus-glib.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "ansi.h"

#include "debug.h"

#include "disco.h"

#include "gabble-connection.h"

#include "gabble-error.h"

#include "namespaces.h"

#include "util.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "telepathy-interfaces.h"

#include "tp-channel-iface.h"

#include "gabble-muc-channel.h"

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

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

#include "gabble_enums.h"

#define DEBUG_FLAG GABBLE_DEBUG_MUC

#define DEFAULT_JOIN_TIMEOUT (180 * 1000)

#define MAX_NICK_RETRIES 3

#define PROPS_POLL_INTERVAL_LOW  (60 * 1000 * 5)

#define PROPS_POLL_INTERVAL_HIGH (60 * 1000)

#ifdef DEBUG_FLAG

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

#define DEBUGGING 0

#define NODE_DEBUG(n, s)

#endif /* DEBUG_FLAG */

#ifndef EMULATOR

G_DEFINE_TYPE_WITH_CODE (GabbleMucChannel, gabble_muc_channel,

    G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));

#endif

/* signal enum */

enum

{

    READY,

    JOIN_ERROR,

    CLOSED,

    PASSWORD_FLAGS_CHANGED,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_MUC

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_muc,guint)

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

    GET_STATIC_VAR_FROM_TLS(gabble_muc_channel_parent_class,gabble_muc,gpointer)

	#define gabble_muc_channel_parent_class (*GET_WSD_VAR_NAME(gabble_muc_channel_parent_class,gabble_muc,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_muc,GType)

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

	/*gchar** _s_gabble_muc_muc_roles() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_muc_muc_roles)); }

	#define muc_roles (GET_WSD_VAR_NAME(muc_roles,gabble_muc, s)())	

	gchar** _s_gabble_muc_muc_affiliations() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_muc_muc_affiliations)); }

	#define muc_affiliations (GET_WSD_VAR_NAME(muc_affiliations,gabble_muc, s)())*/	

static void gabble_muc_channel_init (GabbleMucChannel *self); 

static void gabble_muc_channel_class_init (GabbleMucChannelClass *klass); 

static void gabble_muc_channel_class_intern_init (gpointer klass) 

{

 gabble_muc_channel_parent_class = g_type_class_peek_parent (klass);

  gabble_muc_channel_class_init ((GabbleMucChannelClass*) klass);

} 

EXPORT_C GType gabble_muc_channel_get_type (void)

 { 

 if ((g_define_type_id == 0)) 

 { 

 static const GTypeInfo g_define_type_info = { sizeof (GabbleMucChannelClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_muc_channel_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMucChannel), 0, (GInstanceInitFunc) gabble_muc_channel_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMucChannel"), &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_STATE,

  PROP_INVITE_SELF,

  LAST_PROPERTY

};

typedef enum {

    MUC_STATE_CREATED = 0,

    MUC_STATE_INITIATED,

    MUC_STATE_AUTH,

    MUC_STATE_JOINED,

    MUC_STATE_ENDED,

} GabbleMucState;

#define ENABLE_DEBUG

#ifdef ENABLE_DEBUG

static const gchar *muc_states[] =

{

  "MUC_STATE_CREATED",

  "MUC_STATE_INITIATED",

  "MUC_STATE_AUTH",

  "MUC_STATE_JOINED",

  "MUC_STATE_ENDED",

};

#endif

/* role and affiliation enums */

typedef enum {

    ROLE_NONE = 0,

    ROLE_VISITOR,

    ROLE_PARTICIPANT,

    ROLE_MODERATOR,

    NUM_ROLES,

    INVALID_ROLE,

} GabbleMucRole;

typedef enum {

    AFFILIATION_NONE = 0,

    AFFILIATION_MEMBER,

    AFFILIATION_ADMIN,

    AFFILIATION_OWNER,

    NUM_AFFILIATIONS,

    INVALID_AFFILIATION,

} GabbleMucAffiliation;

//#ifndef EMULATOR

static const gchar *muc_roles[NUM_ROLES] =

{

  "none",

  "visitor",

  "participant",

  "moderator",

};

static const gchar *muc_affiliations[NUM_AFFILIATIONS] =

{

  "none",

  "member",

  "admin",

  "owner",

};

//#endif

/* room properties */

enum

{

  ROOM_PROP_ANONYMOUS = 0,

  ROOM_PROP_INVITE_ONLY,

  ROOM_PROP_MODERATED,

  ROOM_PROP_NAME,

  ROOM_PROP_DESCRIPTION,

  ROOM_PROP_PASSWORD,

  ROOM_PROP_PASSWORD_REQUIRED,

  ROOM_PROP_PERSISTENT,

  ROOM_PROP_PRIVATE,

  ROOM_PROP_SUBJECT,

  ROOM_PROP_SUBJECT_CONTACT,

  ROOM_PROP_SUBJECT_TIMESTAMP,

  NUM_ROOM_PROPS,

  INVALID_ROOM_PROP,

};

const GabblePropertySignature room_property_signatures[NUM_ROOM_PROPS] = {

      { "anonymous",         G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "invite-only",       G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "moderated",         G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "name",              G_TYPE_STRING },   /* impl: READ, WRITE */

      { "description",       G_TYPE_STRING },   /* impl: READ, WRITE */

      { "password",          G_TYPE_STRING },   /* impl: WRITE */

      { "password-required", G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "persistent",        G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "private",           G_TYPE_BOOLEAN },  /* impl: READ, WRITE */

      { "subject",           G_TYPE_STRING },   /* impl: READ, WRITE */

      { "subject-contact",   G_TYPE_UINT },     /* impl: READ */

      { "subject-timestamp", G_TYPE_UINT },     /* impl: READ */

};

/* private structures */

typedef struct _GabbleMucChannelPrivate GabbleMucChannelPrivate;

struct _GabbleMucChannelPrivate

{

  GabbleConnection *conn;

  gchar *object_path;

  GabbleMucState state;

  guint join_timer_id;

  guint poll_timer_id;

  TpChannelPasswordFlags password_flags;

  DBusGMethodInvocation *password_ctx;

  gchar *password;

  GabbleHandle handle;

  const gchar *jid;

  guint nick_retry_count;

  GString *self_jid;

  GabbleMucRole self_role;

  GabbleMucAffiliation self_affil;

  guint recv_id;

  GabblePropertiesContext *properties_ctx;

  gboolean ready_emitted;

  gboolean closed;

  gboolean dispose_has_run;

  gboolean invite_self;

};

#define GABBLE_MUC_CHANNEL_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), GABBLE_TYPE_MUC_CHANNEL, GabbleMucChannelPrivate))

static void

gabble_muc_channel_init (GabbleMucChannel *obj)

{

  /* do nothing? */

}

static void contact_handle_to_room_identity (GabbleMucChannel *, GabbleHandle, GabbleHandle *, GString **);

static GObject *

gabble_muc_channel_constructor (GType type, guint n_props,

                                GObjectConstructParam *props)

{

  GObject *obj;

  GabbleMucChannelPrivate *priv;

  DBusGConnection *bus;

  GabbleHandleRepo *handles;

  GabbleHandle self_handle;

  gboolean valid;

  obj = G_OBJECT_CLASS (gabble_muc_channel_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (obj);

  handles = priv->conn->handles;

  /* ref our room handle */

  valid = gabble_handle_ref (handles, TP_HANDLE_TYPE_ROOM, priv->handle);

  g_assert (valid);

  /* get the room's jid */

  priv->jid = gabble_handle_inspect (handles, TP_HANDLE_TYPE_ROOM, priv->handle);

  /* get our own identity in the room */

  contact_handle_to_room_identity (GABBLE_MUC_CHANNEL (obj), priv->conn->self_handle,

                                   &self_handle, &priv->self_jid);

  valid = gabble_handle_ref (handles, TP_HANDLE_TYPE_CONTACT, self_handle);

  g_assert (valid);

  /* initialize our own role and affiliation */

  priv->self_role = ROLE_NONE;

  priv->self_affil = AFFILIATION_NONE;

  /* register object on the bus */

  bus = tp_get_bus ();

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

  /* initialize group mixin */

  gabble_group_mixin_init (obj, G_STRUCT_OFFSET (GabbleMucChannel, group),

                           handles, self_handle);

  /* set initial group flags */

  gabble_group_mixin_change_flags (obj,

      TP_CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES |

      TP_CHANNEL_GROUP_FLAG_CAN_ADD,

      0);

  /* initialize properties mixin */

  gabble_properties_mixin_init (obj, G_STRUCT_OFFSET (

        GabbleMucChannel, properties));

  /* initialize text mixin */

  gabble_text_mixin_init (obj, G_STRUCT_OFFSET (GabbleMucChannel, text), handles, FALSE);

  gabble_text_mixin_set_message_types (obj,

      TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL,

      TP_CHANNEL_TEXT_MESSAGE_TYPE_ACTION,

      G_MAXUINT);

  /* add ourselves to group mixin if needed */

  if (priv->invite_self)

    {

      GError *error = NULL;

      GArray *members = g_array_sized_new (FALSE, FALSE, sizeof (GabbleHandle), 1);

      g_array_append_val (members, self_handle);

      gabble_group_mixin_add_members (obj, members, "", &error);

      g_assert (error == NULL);

      g_array_free (members, TRUE);

    }

  return obj;

}

static void

properties_disco_cb (GabbleDisco *disco,

                     GabbleDiscoRequest *request,

                     const gchar *jid,

                     const gchar *node,

                     LmMessageNode *query_result,

                     GError *error,

                     gpointer user_data)

{

  GabbleMucChannel *chan = user_data;

  GabbleMucChannelPrivate *priv;

  GArray *changed_props_val, *changed_props_flags;

  LmMessageNode *lm_node;

  const gchar *str;

  GValue val = { 0, };

  g_assert (GABBLE_IS_MUC_CHANNEL (chan));

  priv = GABBLE_MUC_CHANNEL_GET_PRIVATE (chan);

  if (error)

    {

      gabble_debug (DEBUG_FLAG, "got error %s", error->message);

      return;

    }

  NODE_DEBUG (query_result, "disco query result");

  changed_props_val = changed_props_flags = NULL;

  /*

   * Update room definition.

   */

  /* ROOM_PROP_NAME */

  lm_node = lm_message_node_get_child (query_result, "identity");

  if (lm_node)

    {

      const gchar *type, *category, *name;

      type = lm_message_node_get_attribute (lm_node, "type");

      category = lm_message_node_get_attribute (lm_node, "category");

      name = lm_message_node_get_attribute (lm_node, "name");

      if (NULL != type && 0 == strcmp (type, "text") &&

          NULL != category && 0 == strcmp (category, "conference") &&

          NULL != name)

        {

          g_value_init (&val, G_TYPE_STRING);

          g_value_set_string (&val, name);

          gabble_properties_mixin_change_value (G_OBJECT (chan), ROOM_PROP_NAME,

                                                &val, &changed_props_val);

          gabble_properties_mixin_change_flags (G_OBJECT (chan), ROOM_PROP_NAME,

                                                TP_PROPERTY_FLAG_READ,

                                                0, &changed_props_flags);

          g_value_unset (&val);

        }

    }

  for (lm_node = query_result->children; lm_node; lm_node = lm_node->next)

    {

      guint prop_id = INVALID_ROOM_PROP;

      if (strcmp (lm_node->name, "feature") == 0)

        {

          str = lm_message_node_get_attribute (lm_node, "var");

          if (str == NULL)

            continue;

          /* ROOM_PROP_ANONYMOUS */

          if (strcmp (str, "muc_nonanonymous") == 0)

            {

              prop_id = ROOM_PROP_ANONYMOUS;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_semianonymous") == 0 ||

                   strcmp (str, "muc_anonymous") == 0)

            {

              prop_id = ROOM_PROP_ANONYMOUS;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* ROOM_PROP_INVITE_ONLY */

          else if (strcmp (str, "muc_open") == 0)

            {

              prop_id = ROOM_PROP_INVITE_ONLY;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_membersonly") == 0)

            {

              prop_id = ROOM_PROP_INVITE_ONLY;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* ROOM_PROP_MODERATED */

          else if (strcmp (str, "muc_unmoderated") == 0)

            {

              prop_id = ROOM_PROP_MODERATED;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_moderated") == 0)

            {

              prop_id = ROOM_PROP_MODERATED;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* ROOM_PROP_PASSWORD_REQUIRED */

          else if (strcmp (str, "muc_unsecure") == 0 ||

                   strcmp (str, "muc_unsecured") == 0)

            {

              prop_id = ROOM_PROP_PASSWORD_REQUIRED;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_passwordprotected") == 0)

            {

              prop_id = ROOM_PROP_PASSWORD_REQUIRED;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* ROOM_PROP_PERSISTENT */

          else if (strcmp (str, "muc_temporary") == 0)

            {

              prop_id = ROOM_PROP_PERSISTENT;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_persistent") == 0)

            {

              prop_id = ROOM_PROP_PERSISTENT;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* ROOM_PROP_PRIVATE */

          else if (strcmp (str, "muc_public") == 0)

            {

              prop_id = ROOM_PROP_PRIVATE;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, FALSE);

            }

          else if (strcmp (str, "muc_hidden") == 0)

            {

              prop_id = ROOM_PROP_PRIVATE;

              g_value_init (&val, G_TYPE_BOOLEAN);

              g_value_set_boolean (&val, TRUE);

            }

          /* Ignored */

          else if (strcmp (str, NS_MUC) == 0)

            {

            }

          /* Unhandled */

          else

            {

              g_warning ("%s: unhandled feature '%s'", G_STRFUNC, str);

            }

        }