/*

 * gabble-roster-channel.c - Source for GabbleRosterChannel

 * 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>

#define DEBUG_FLAG GABBLE_DEBUG_ROSTER

#include "debug.h"

#include "gabble-connection.h"

#include "gintset.h"

#include "group-mixin.h"

#include "handle-set.h"

#include "roster.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "telepathy-interfaces.h"

#include "tp-channel-iface.h"

#include "util.h"

#include "gabble-roster-channel.h"

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

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

#include "gabble_enums.h"

#ifndef EMULATOR

G_DEFINE_TYPE_WITH_CODE (GabbleRosterChannel, gabble_roster_channel,

    G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));

#endif

/* signal enum */

enum

{

    CLOSED,

    GROUP_FLAGS_CHANGED,

    MEMBERS_CHANGED,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_ROS_CHNL

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_ros_chnl,guint)

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

	GET_STATIC_VAR_FROM_TLS(gabble_roster_channel_parent_class,gabble_ros_chnl,gpointer)

	#define gabble_roster_channel_parent_class (*GET_WSD_VAR_NAME(gabble_roster_channel_parent_class,gabble_ros_chnl,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_ros_chnl,GType)

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

static void gabble_roster_channel_init (GabbleRosterChannel *self); 

static void gabble_roster_channel_class_init (GabbleRosterChannelClass *klass); 

static void gabble_roster_channel_class_intern_init (gpointer klass) 

{

 gabble_roster_channel_parent_class = g_type_class_peek_parent (klass); 

 gabble_roster_channel_class_init ((GabbleRosterChannelClass*) klass);

  }

 EXPORT_C GType gabble_roster_channel_get_type (void) 

 {

  if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleRosterChannelClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_roster_channel_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleRosterChannel), 0, (GInstanceInitFunc) gabble_roster_channel_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleRosterChannel"), &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,

  LAST_PROPERTY

};

/* private structure */

typedef struct _GabbleRosterChannelPrivate GabbleRosterChannelPrivate;

struct _GabbleRosterChannelPrivate

{

  GabbleConnection *conn;

  char *object_path;

  GabbleHandle handle;

  gboolean dispose_has_run;

};

#define GABBLE_ROSTER_CHANNEL_GET_PRIVATE(obj) \

    ((GabbleRosterChannelPrivate *)obj->priv)

static void

gabble_roster_channel_init (GabbleRosterChannel *self)

{

  GabbleRosterChannelPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_ROSTER_CHANNEL, GabbleRosterChannelPrivate);

  self->priv = priv;

  /* allocate any data required by the object here */

}

static GObject *

gabble_roster_channel_constructor (GType type, guint n_props,

                                   GObjectConstructParam *props)

{

  GObject *obj;

  GabbleRosterChannelPrivate *priv;

  DBusGConnection *bus;

  GabbleHandleRepo *handles;

  gboolean valid;

  GabbleHandle self_handle;

  obj = G_OBJECT_CLASS (gabble_roster_channel_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (GABBLE_ROSTER_CHANNEL (obj));

  handles = priv->conn->handles;

  self_handle = priv->conn->self_handle;

  /* register object on the bus */

  bus = tp_get_bus ();

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

  /* ref our list handle */

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

  g_assert (valid);

  /* initialize group mixin */

  gabble_group_mixin_init (obj, G_STRUCT_OFFSET (GabbleRosterChannel, group),

                           handles, self_handle);

  if (GABBLE_LIST_HANDLE_PUBLISH == priv->handle)

    {

      gabble_group_mixin_change_flags (obj,

          TP_CHANNEL_GROUP_FLAG_CAN_REMOVE |

          TP_CHANNEL_GROUP_FLAG_MESSAGE_ACCEPT |

          TP_CHANNEL_GROUP_FLAG_MESSAGE_REMOVE,

          0);

    }

  else if (GABBLE_LIST_HANDLE_SUBSCRIBE == priv->handle)

    {

      gabble_group_mixin_change_flags (obj,

          TP_CHANNEL_GROUP_FLAG_CAN_ADD |

          TP_CHANNEL_GROUP_FLAG_CAN_REMOVE |

          TP_CHANNEL_GROUP_FLAG_CAN_RESCIND |

          TP_CHANNEL_GROUP_FLAG_MESSAGE_ADD |

          TP_CHANNEL_GROUP_FLAG_MESSAGE_REMOVE |

          TP_CHANNEL_GROUP_FLAG_MESSAGE_RESCIND,

          0);

    }

  else if (GABBLE_LIST_HANDLE_KNOWN == priv->handle)

    {

      gabble_group_mixin_change_flags (obj,

          TP_CHANNEL_GROUP_FLAG_CAN_REMOVE,

          0);

    }

  else if (GABBLE_LIST_HANDLE_DENY == priv->handle)

    {

      gabble_group_mixin_change_flags (obj,

          TP_CHANNEL_GROUP_FLAG_CAN_ADD |

          TP_CHANNEL_GROUP_FLAG_CAN_REMOVE,

          0);

    }

  else

    {

      g_assert_not_reached ();

    }

  return obj;

}

static void

gabble_roster_channel_get_property (GObject    *object,

                                    guint       property_id,

                                    GValue     *value,

                                    GParamSpec *pspec)

{

  GabbleRosterChannel *chan = GABBLE_ROSTER_CHANNEL (object);

  GabbleRosterChannelPrivate *priv = GABBLE_ROSTER_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_CONTACT_LIST);

      break;

    case PROP_HANDLE_TYPE:

      g_value_set_uint (value, TP_HANDLE_TYPE_LIST);

      break;

    case PROP_HANDLE:

      g_value_set_uint (value, priv->handle);

      break;

    case PROP_CONNECTION:

      g_value_set_object (value, priv->conn);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_roster_channel_set_property (GObject     *object,

                                    guint        property_id,

                                    const GValue *value,

                                    GParamSpec   *pspec)

{

  GabbleRosterChannel *chan = GABBLE_ROSTER_CHANNEL (object);

  GabbleRosterChannelPrivate *priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (chan);

  switch (property_id) {

    case PROP_OBJECT_PATH:

      g_free (priv->object_path);

      priv->object_path = g_value_dup_string (value);

      break;

    case PROP_HANDLE:

      priv->handle = g_value_get_uint (value);

      break;

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void gabble_roster_channel_dispose (GObject *object);

static void gabble_roster_channel_finalize (GObject *object);

static gboolean _gabble_roster_channel_add_member_cb (GObject *obj, GabbleHandle handle, const gchar *message, GError **error);

static gboolean _gabble_roster_channel_remove_member_cb (GObject *obj, GabbleHandle handle, const gchar *message, GError **error);

static void

gabble_roster_channel_class_init (GabbleRosterChannelClass *gabble_roster_channel_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_roster_channel_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_roster_channel_class, sizeof (GabbleRosterChannelPrivate));

  object_class->constructor = gabble_roster_channel_constructor;

  object_class->get_property = gabble_roster_channel_get_property;

  object_class->set_property = gabble_roster_channel_set_property;

  object_class->dispose = gabble_roster_channel_dispose;

  object_class->finalize = gabble_roster_channel_finalize;

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

                                    "Gabble connection object that owns this "

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

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

  signals[CLOSED] =

    g_signal_new ("closed",

                  G_OBJECT_CLASS_TYPE (gabble_roster_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__VOID,

                  G_TYPE_NONE, 0);

  gabble_group_mixin_class_init (object_class,

                                 G_STRUCT_OFFSET (GabbleRosterChannelClass, group_class),

                                 _gabble_roster_channel_add_member_cb,

                                 _gabble_roster_channel_remove_member_cb);

  dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_roster_channel_class), &dbus_glib_gabble_roster_channel_object_info);

}

void

gabble_roster_channel_dispose (GObject *object)

{

  GabbleRosterChannel *self = GABBLE_ROSTER_CHANNEL (object);

  GabbleRosterChannelPrivate *priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (self);

  if (priv->dispose_has_run)

    return;

  priv->dispose_has_run = TRUE;

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

  /* release any references held by the object here */

  if (G_OBJECT_CLASS (gabble_roster_channel_parent_class)->dispose)

    G_OBJECT_CLASS (gabble_roster_channel_parent_class)->dispose (object);

}

void

gabble_roster_channel_finalize (GObject *object)

{

  GabbleRosterChannel *self = GABBLE_ROSTER_CHANNEL (object);

  GabbleRosterChannelPrivate *priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (self);

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

  g_free (priv->object_path);

  gabble_handle_unref (priv->conn->handles, TP_HANDLE_TYPE_LIST, priv->handle);

  gabble_group_mixin_finalize (object);

  G_OBJECT_CLASS (gabble_roster_channel_parent_class)->finalize (object);

}

static gboolean

_gabble_roster_channel_send_presence (GabbleRosterChannel *chan,

                                      LmMessageSubType sub_type,

                                      GabbleHandle handle,

                                      const gchar *status,

                                      GError **error)

{

  GabbleRosterChannelPrivate *priv;

  GabbleHandleRepo *repo;

  const char *contact;

  LmMessage *message;

  gboolean result;

  priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (chan);

  repo = priv->conn->handles;

  contact = gabble_handle_inspect (repo, TP_HANDLE_TYPE_CONTACT, handle);

  message = lm_message_new_with_sub_type (contact,

      LM_MESSAGE_TYPE_PRESENCE,

      sub_type);

  if (LM_MESSAGE_SUB_TYPE_SUBSCRIBE == sub_type)

    lm_message_node_add_own_nick (message->node, priv->conn);

  if (status != NULL && status[0] != '\0')

    lm_message_node_add_child (message->node, "status", status);

  result = _gabble_connection_send (priv->conn, message, error);

  lm_message_unref (message);

  return result;

}

/**

 * _gabble_roster_channel_add_member_cb

 *

 * Called by the group mixin to add one member.

 */

static gboolean

_gabble_roster_channel_add_member_cb (GObject *obj,

                                      GabbleHandle handle,

                                      const gchar *message,

                                      GError **error)

{

  GabbleRosterChannelPrivate *priv;

  GabbleHandleRepo *repo;

  gboolean ret = FALSE;

  priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (GABBLE_ROSTER_CHANNEL (obj));

  repo = priv->conn->handles;

  gabble_debug (DEBUG_FLAG, "called on %s with handle %u (%s) \"%s\"", gabble_handle_inspect (repo, TP_HANDLE_TYPE_LIST, priv->handle), handle,

      gabble_handle_inspect (repo, TP_HANDLE_TYPE_CONTACT, handle), message);

  /* publish list */

  if (GABBLE_LIST_HANDLE_PUBLISH == priv->handle)

    {

      /* send <presence type="subscribed"> */

      ret = _gabble_roster_channel_send_presence (GABBLE_ROSTER_CHANNEL (obj),

          LM_MESSAGE_SUB_TYPE_SUBSCRIBED, handle, message, error);

    }

  /* subscribe list */

  else if (GABBLE_LIST_HANDLE_SUBSCRIBE == priv->handle)

    {

      /* add item to the roster (GTalk depends on this, clearing the H flag) */

      gabble_roster_handle_add (priv->conn->roster, handle, NULL);

      /* send <presence type="subscribe"> */

      ret = _gabble_roster_channel_send_presence (GABBLE_ROSTER_CHANNEL (obj),

          LM_MESSAGE_SUB_TYPE_SUBSCRIBE, handle, message, error);

    }

  /* deny list */

  else if (GABBLE_LIST_HANDLE_DENY == priv->handle)

    {

      /* block contact */

      ret = gabble_roster_handle_set_blocked (priv->conn->roster, handle, TRUE,

          error);

    }

  else

    {

      g_assert_not_reached ();

    }

  return ret;

}

/**

 * _gabble_roster_channel_remove_member_cb

 *

 * Called by the group mixin to remove one member.

 */

static gboolean

_gabble_roster_channel_remove_member_cb (GObject *obj,

                                         GabbleHandle handle,

                                         const gchar *message,

                                         GError **error)

{

  GabbleRosterChannelPrivate *priv;

  GabbleHandleRepo *repo;

  gboolean ret = FALSE;

  priv = GABBLE_ROSTER_CHANNEL_GET_PRIVATE (GABBLE_ROSTER_CHANNEL (obj));

  repo = priv->conn->handles;

  gabble_debug (DEBUG_FLAG, "called on %s with handle %u (%s) \"%s\"", gabble_handle_inspect (repo, TP_HANDLE_TYPE_LIST, priv->handle), handle,

      gabble_handle_inspect (repo, TP_HANDLE_TYPE_CONTACT, handle), message);

  /* publish list */

  if (GABBLE_LIST_HANDLE_PUBLISH == priv->handle)

    {

      /* send <presence type="unsubscribed"> */

      ret = _gabble_roster_channel_send_presence (GABBLE_ROSTER_CHANNEL (obj),

          LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED, handle, message, error);

      /* remove it from local_pending here, because roster callback doesn't

         know if it can (subscription='none' is used both during request and

         when it's rejected) */

      if (handle_set_is_member (GABBLE_ROSTER_CHANNEL (obj)->group.local_pending, handle))

        {

          GIntSet *rem = g_intset_new ();

          g_intset_add (rem, handle);

          gabble_group_mixin_change_members (obj, "", NULL, rem, NULL, NULL,

              0, 0);

          g_intset_destroy (rem);

        }

    }

  /* subscribe list */

  else if (GABBLE_LIST_HANDLE_SUBSCRIBE == priv->handle)

    {

      /* send <presence type="unsubscribe"> */

      ret = _gabble_roster_channel_send_presence (GABBLE_ROSTER_CHANNEL (obj),

          LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE, handle, message, error);

    }

  /* known list */

  else if (GABBLE_LIST_HANDLE_KNOWN == priv->handle)

    {

      /* send roster subscription=remove IQ */

      ret = gabble_roster_handle_remove (priv->conn->roster, handle, error);

    }

  /* deny list */

  else if (GABBLE_LIST_HANDLE_DENY == priv->handle)

    {

      /* unblock contact */

      ret = gabble_roster_handle_set_blocked (priv->conn->roster, handle, FALSE,

          error);

    }

  else

    {

      g_assert_not_reached ();

    }

  return ret;

}

/**

 * gabble_roster_channel_add_members

 *

 * Implements D-Bus method AddMembers

 * on interface org.freedesktop.Telepathy.Channel.Interface.Group

 *

 * @error: Used to return a pointer to a GError detailing any error

 *         that occurred, D-Bus will throw the error only if this

 *         function returns FALSE.

 *

 * Returns: TRUE if successful, FALSE if an error was thrown.

 */

gboolean

gabble_roster_channel_add_members (GabbleRosterChannel *self,

                                   const GArray *contacts,

                                   const gchar *message,

                                   GError **error)