/*

 * gabble-media-channel.c - Source for GabbleMediaChannel

 * 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 "ansi.h"

#include "debug.h"

#include "gabble-connection.h"

#include "gabble-media-session.h"

#include "gabble-presence.h"

#include "gabble-presence-cache.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "telepathy-interfaces.h"

#include "tp-channel-iface.h"

#include "gabble-media-channel.h"

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

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

#include "gabble-media-session.h"

#include "gabble-media-stream.h"

#include "media-factory.h"

#include "gabble_enums.h"

#define DEBUG_FLAG GABBLE_DEBUG_MEDIA

#define TP_SESSION_HANDLER_SET_TYPE (dbus_g_type_get_struct ("GValueArray", \

      DBUS_TYPE_G_OBJECT_PATH, \

      G_TYPE_STRING, \

      G_TYPE_INVALID))

#define TP_CHANNEL_STREAM_TYPE (dbus_g_type_get_struct ("GValueArray", \

      G_TYPE_UINT, \

      G_TYPE_UINT, \

      G_TYPE_UINT, \

      G_TYPE_UINT, \

      G_TYPE_UINT, \

      G_TYPE_UINT, \

      G_TYPE_INVALID))

#ifndef EMULATOR

G_DEFINE_TYPE_WITH_CODE (GabbleMediaChannel, gabble_media_channel,

    G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE (TP_TYPE_CHANNEL_IFACE, NULL));

#endif

/* signal enum */

enum

{

    CLOSED,

    NEW_SESSION_HANDLER,

    STREAM_ADDED,

    STREAM_DIRECTION_CHANGED,

    STREAM_ERROR,

    STREAM_REMOVED,

    STREAM_STATE_CHANGED,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_MED_CHANNEL

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_chnl,guint)

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

	GET_STATIC_VAR_FROM_TLS(gabble_media_channel_parent_class,gabble_med_chnl,gpointer)

	#define gabble_media_channel_parent_class (*GET_WSD_VAR_NAME(gabble_media_channel_parent_class,gabble_med_chnl,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_chnl,GType)

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

static void gabble_media_channel_init (GabbleMediaChannel *self); 

static void gabble_media_channel_class_init (GabbleMediaChannelClass *klass);

static void gabble_media_channel_class_intern_init (gpointer klass)

 { 

 gabble_media_channel_parent_class = g_type_class_peek_parent (klass); 

 gabble_media_channel_class_init ((GabbleMediaChannelClass*) klass); 

 } 

 EXPORT_C GType gabble_media_channel_get_type (void)

  { 

  if ((g_define_type_id == 0))

   { static const GTypeInfo g_define_type_info = { sizeof (GabbleMediaChannelClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_media_channel_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMediaChannel), 0, (GInstanceInitFunc) gabble_media_channel_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMediaChannel"), &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_CREATOR,

  PROP_FACTORY,

  LAST_PROPERTY

};

/* private structure */

typedef struct _GabbleMediaChannelPrivate GabbleMediaChannelPrivate;

struct _GabbleMediaChannelPrivate

{

  GabbleConnection *conn;

  gchar *object_path;

  GabbleHandle creator;

  GabbleMediaFactory *factory;

  GabbleMediaSession *session;

  GPtrArray *streams;

  guint next_stream_id;

  gboolean closed;

  gboolean dispose_has_run;

};

#define GABBLE_MEDIA_CHANNEL_GET_PRIVATE(obj) \

    ((GabbleMediaChannelPrivate *)obj->priv)

static void

gabble_media_channel_init (GabbleMediaChannel *self)

{

  GabbleMediaChannelPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_MEDIA_CHANNEL, GabbleMediaChannelPrivate);

  self->priv = priv;

  priv->next_stream_id = 1;

}

static GObject *

gabble_media_channel_constructor (GType type, guint n_props,

                                  GObjectConstructParam *props)

{

  GObject *obj;

  GabbleMediaChannelPrivate *priv;

  DBusGConnection *bus;

  GIntSet *set;

  obj = G_OBJECT_CLASS (gabble_media_channel_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_MEDIA_CHANNEL_GET_PRIVATE (GABBLE_MEDIA_CHANNEL (obj));

  /* register object on the bus */

  bus = tp_get_bus ();

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

  gabble_group_mixin_init (obj, G_STRUCT_OFFSET (GabbleMediaChannel, group),

                           priv->conn->handles, priv->conn->self_handle);

  /* automatically add creator to channel */

  set = g_intset_new ();

  g_intset_add (set, priv->creator);

  gabble_group_mixin_change_members (obj, "", set, NULL, NULL, NULL, 0, 0);

  g_intset_destroy (set);

  /* allow member adding */

  gabble_group_mixin_change_flags (obj, TP_CHANNEL_GROUP_FLAG_CAN_ADD, 0);

  return obj;

}

static void session_state_changed_cb (GabbleMediaSession *session, GParamSpec *arg1, GabbleMediaChannel *channel);

static void session_stream_added_cb (GabbleMediaSession *session, GabbleMediaStream  *stream, GabbleMediaChannel *chan);

static void session_terminated_cb (GabbleMediaSession *session, guint terminator, guint reason, gpointer user_data);

/**

 * create_session

 *

 * Creates a GabbleMediaSession object for given peer.

 *

 * If sid is set to NULL a unique sid is generated and

 * the "initiator" property of the newly created

 * GabbleMediaSession is set to our own handle.

 */

static GabbleMediaSession*

create_session (GabbleMediaChannel *channel,

                GabbleHandle peer,

                const gchar *peer_resource,

                const gchar *sid)

{

  GabbleMediaChannelPrivate *priv;

  GabbleMediaSession *session;

  gchar *object_path;

  JingleInitiator initiator;

  g_assert (GABBLE_IS_MEDIA_CHANNEL (channel));

  priv = GABBLE_MEDIA_CHANNEL_GET_PRIVATE (channel);

  g_assert (priv->session == NULL);

  object_path = g_strdup_printf ("%s/MediaSession%u", priv->object_path, peer);

  if (sid == NULL)

    {

      initiator = INITIATOR_LOCAL;

      sid = _gabble_media_factory_allocate_sid (priv->factory, channel);

    }

  else

    {

      initiator = INITIATOR_REMOTE;

      _gabble_media_factory_register_sid (priv->factory, sid, channel);

    }

  session = g_object_new (GABBLE_TYPE_MEDIA_SESSION,

                          "connection", priv->conn,

                          "media-channel", channel,

                          "object-path", object_path,

                          "session-id", sid,

                          "initiator", initiator,

                          "peer", peer,

                          "peer-resource", peer_resource,

                          NULL);

  g_signal_connect (session, "notify::state",

                    (GCallback) session_state_changed_cb, channel);

  g_signal_connect (session, "stream-added",

                    (GCallback) session_stream_added_cb, channel);

  g_signal_connect (session, "terminated",

                    (GCallback) session_terminated_cb, channel);

  priv->session = session;

  priv->streams = g_ptr_array_sized_new (1);

  g_signal_emit (channel, signals[NEW_SESSION_HANDLER], 0,

                 object_path, "rtp");

  g_free (object_path);

  return session;

}

gboolean

_gabble_media_channel_dispatch_session_action (GabbleMediaChannel *chan,

                                               GabbleHandle peer,

                                               const gchar *peer_resource,

                                               const gchar *sid,

                                               LmMessage *message,

                                               LmMessageNode *session_node,

                                               const gchar *action,

                                               GError **error)

{

  GabbleMediaChannelPrivate *priv = GABBLE_MEDIA_CHANNEL_GET_PRIVATE (chan);

  GabbleMediaSession *session = priv->session;

  gboolean session_is_new = FALSE;

  if (session == NULL)

    {

      GabbleGroupMixin *mixin = GABBLE_GROUP_MIXIN (chan);

      GIntSet *set;

      session = create_session (chan, peer, peer_resource, sid);

      session_is_new = TRUE;

      /* make us local pending */

      set = g_intset_new ();

      g_intset_add (set, mixin->self_handle);

      gabble_group_mixin_change_members (G_OBJECT (chan), "", NULL, NULL, set,

          NULL, 0, 0);

      g_intset_destroy (set);

      /* and update flags accordingly */

      gabble_group_mixin_change_flags (G_OBJECT (chan),

                                       TP_CHANNEL_GROUP_FLAG_CAN_ADD |

                                       TP_CHANNEL_GROUP_FLAG_CAN_REMOVE,

                                       0);

    }

  g_object_ref (session);

  if (_gabble_media_session_handle_action (session, message, session_node,

        action, error))

    {

      g_object_unref (session);

      return TRUE;

    }

  else

    {

      if (session_is_new)

        _gabble_media_session_terminate (session, INITIATOR_LOCAL,

            TP_CHANNEL_GROUP_CHANGE_REASON_ERROR);

      g_object_unref (session);

      return FALSE;

    }

}

static void

gabble_media_channel_get_property (GObject    *object,

                                   guint       property_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  GabbleMediaChannel *chan = GABBLE_MEDIA_CHANNEL (object);

  GabbleMediaChannelPrivate *priv = GABBLE_MEDIA_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_STREAMED_MEDIA);

      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_CREATOR:

      g_value_set_uint (value, priv->creator);

      break;

    case PROP_FACTORY:

      g_value_set_object (value, priv->factory);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_media_channel_set_property (GObject     *object,

                                   guint        property_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  GabbleMediaChannel *chan = GABBLE_MEDIA_CHANNEL (object);

  GabbleMediaChannelPrivate *priv = GABBLE_MEDIA_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:

      /* 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);

      break;

    case PROP_CREATOR:

      priv->creator = g_value_get_uint (value);

      break;

    case PROP_FACTORY:

      priv->factory = g_value_get_object (value);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void gabble_media_channel_dispose (GObject *object);

static void gabble_media_channel_finalize (GObject *object);

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

static void

gabble_media_channel_class_init (GabbleMediaChannelClass *gabble_media_channel_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_channel_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_media_channel_class, sizeof (GabbleMediaChannelPrivate));

  object_class->constructor = gabble_media_channel_constructor;

  object_class->get_property = gabble_media_channel_get_property;

  object_class->set_property = gabble_media_channel_set_property;

  object_class->dispose = gabble_media_channel_dispose;

  object_class->finalize = gabble_media_channel_finalize;

  gabble_group_mixin_class_init (object_class,

                                 G_STRUCT_OFFSET (GabbleMediaChannelClass, group_class),

                                 _gabble_media_channel_add_member,

                                 gabble_media_channel_remove_member);

  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 "

                                    "media 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_uint ("creator", "Channel creator",

                                  "The GabbleHandle representing the contact "

                                  "who created the channel.",

                                  0, G_MAXUINT32, 0,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_CREATOR, param_spec);

  param_spec = g_param_spec_object ("factory", "GabbleMediaFactory object",

                                    "The factory that created this object.",

                                    GABBLE_TYPE_MEDIA_FACTORY,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NICK |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_FACTORY, param_spec);

  signals[CLOSED] =

    g_signal_new ("closed",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__VOID,

                  G_TYPE_NONE, 0);

  signals[NEW_SESSION_HANDLER] =

    g_signal_new ("new-session-handler",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  gabble_media_channel_marshal_VOID__STRING_STRING,

                  G_TYPE_NONE, 2, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING);

  signals[STREAM_ADDED] =

    g_signal_new ("stream-added",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  gabble_media_channel_marshal_VOID__UINT_UINT_UINT,

                  G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);

  signals[STREAM_DIRECTION_CHANGED] =

    g_signal_new ("stream-direction-changed",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  gabble_media_channel_marshal_VOID__UINT_UINT_UINT,

                  G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);

  signals[STREAM_ERROR] =

    g_signal_new ("stream-error",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  gabble_media_channel_marshal_VOID__UINT_UINT_STRING,

                  G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING);

  signals[STREAM_REMOVED] =

    g_signal_new ("stream-removed",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  g_cclosure_marshal_VOID__UINT,

                  G_TYPE_NONE, 1, G_TYPE_UINT);

  signals[STREAM_STATE_CHANGED] =

    g_signal_new ("stream-state-changed",

                  G_OBJECT_CLASS_TYPE (gabble_media_channel_class),

                  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                  0,

                  NULL, NULL,

                  gabble_media_channel_marshal_VOID__UINT_UINT,

                  G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);

  dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (gabble_media_channel_class), &dbus_glib_gabble_media_channel_object_info);

}

void

gabble_media_channel_dispose (GObject *object)

{

  GabbleMediaChannel *self = GABBLE_MEDIA_CHANNEL (object);