/*

 * gabble-media-session.c - Source for GabbleMediaSession

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

#include "ansi.h"

#include "handles.h"

#include "namespaces.h"

#include "util.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "gabble-connection.h"

#include "gabble-media-channel.h"

#include "gabble-media-stream.h"

#include "gabble-presence-cache.h"

#include "gabble-presence.h"

#include "gabble-media-session.h"

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

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

#include "gabble_enums.h"

#ifndef EMULATOR

G_DEFINE_TYPE(GabbleMediaSession, gabble_media_session, G_TYPE_OBJECT)

#endif

#define DEBUG_FLAG GABBLE_DEBUG_MEDIA

//vinod

#ifdef DEBUG_FLAG

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

#define DEBUGGING 0

//#define NODE_DEBUG(n, s);

#endif /* DEBUG_FLAG */

#define DEFAULT_SESSION_TIMEOUT 50000

#define GTALK_STREAM_NAME "gtalk"

/* 99 streams gives us a max name length of 8 (videoXX\0 or audioXX\0) */

#define MAX_STREAMS 99

#ifndef EMULATOR

#define MAX_STREAM_NAME_LEN 8

#endif

//#define DEBUGGING 0

/* signal enum */

enum

{

    NEW_STREAM_HANDLER,

    STREAM_ADDED,

    TERMINATED,

    LAST_SIGNAL

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_med_sess,guint)

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

	GET_STATIC_VAR_FROM_TLS(google_audio_caps,gabble_med_sess,GabblePresenceCapabilities)

	#define google_audio_caps (*GET_WSD_VAR_NAME(google_audio_caps,gabble_med_sess, s)())	

	GET_STATIC_VAR_FROM_TLS(jingle_audio_caps,gabble_med_sess,GabblePresenceCapabilities)

	#define jingle_audio_caps (*GET_WSD_VAR_NAME(jingle_audio_caps,gabble_med_sess, s)())	

	GET_STATIC_VAR_FROM_TLS(jingle_video_caps,gabble_med_sess,GabblePresenceCapabilities)

	#define jingle_video_caps (*GET_WSD_VAR_NAME(jingle_video_caps,gabble_med_sess, s)())	

	GET_STATIC_ARRAY_FROM_TLS(ret_sess,gabble_med_sess,gchar)

	#define ret_sess (GET_WSD_VAR_NAME(ret_sess,gabble_med_sess, s)())	

	GET_STATIC_VAR_FROM_TLS(gabble_media_session_parent_class,gabble_med_sess,gpointer)

	#define gabble_media_session_parent_class (*GET_WSD_VAR_NAME(gabble_media_session_parent_class,gabble_med_sess,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_med_sess,GType)

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

	static void gabble_media_session_init (GabbleMediaSession *self); 

	static void gabble_media_session_class_init (GabbleMediaSessionClass *klass); 

	static void gabble_media_session_class_intern_init (gpointer klass) 

	{ 

	gabble_media_session_parent_class = g_type_class_peek_parent (klass); 

	gabble_media_session_class_init ((GabbleMediaSessionClass*) klass); }

	 EXPORT_C GType gabble_media_session_get_type (void) 

	 { 

	 if ((g_define_type_id == 0)) { static const GTypeInfo g_define_type_info = { sizeof (GabbleMediaSessionClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_media_session_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleMediaSession), 0, (GInstanceInitFunc) gabble_media_session_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleMediaSession"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

	 }

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif

/* properties */

enum

{

  PROP_CONNECTION = 1,

  PROP_MEDIA_CHANNEL,

  PROP_OBJECT_PATH,

  PROP_SESSION_ID,

  PROP_INITIATOR,

  PROP_PEER,

  PROP_PEER_RESOURCE,

  PROP_STATE,

  LAST_PROPERTY

};

/* private structure */

typedef struct _GabbleMediaSessionPrivate GabbleMediaSessionPrivate;

struct _GabbleMediaSessionPrivate

{

  GabbleConnection *conn;

  GabbleMediaChannel *channel;

  GabbleMediaSessionMode mode;

  gchar *object_path;

  GPtrArray *streams;

  GPtrArray *remove_requests;

  gchar *id;

  GabbleHandle peer;

  gchar *peer_resource;

  JingleSessionState state;

  gboolean ready;

  gboolean locally_accepted;

  gboolean terminated;

  guint timer_id;

  gboolean dispose_has_run;

};

#define GABBLE_MEDIA_SESSION_GET_PRIVATE(obj) \

    ((GabbleMediaSessionPrivate *)obj->priv)

typedef struct {

    gchar *name;

    gchar *attributes;

} SessionStateDescription;

static const SessionStateDescription session_states[] =

{

    { "JS_STATE_PENDING_CREATED",       ANSI_BOLD_ON ANSI_FG_BLACK ANSI_BG_WHITE   },

    { "JS_STATE_PENDING_INITIATE_SENT", ANSI_BOLD_ON               ANSI_BG_CYAN    },

    { "JS_STATE_PENDING_INITIATED",     ANSI_BOLD_ON               ANSI_BG_MAGENTA },

    { "JS_STATE_PENDING_ACCEPT_SENT",   ANSI_BOLD_ON               ANSI_BG_CYAN    },

    { "JS_STATE_ACTIVE",                ANSI_BOLD_ON               ANSI_BG_BLUE    },

    { "JS_STATE_ENDED",                                            ANSI_BG_RED     }

};

static void

gabble_media_session_init (GabbleMediaSession *self)

{

  GabbleMediaSessionPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_MEDIA_SESSION, GabbleMediaSessionPrivate);

  self->priv = priv;

  priv->mode = MODE_JINGLE;

  priv->state = JS_STATE_PENDING_CREATED;

  priv->streams = g_ptr_array_new ();

  priv->remove_requests = g_ptr_array_new ();

}

static void stream_connection_state_changed_cb (GabbleMediaStream *stream,

                                                GParamSpec *param,

                                                GabbleMediaSession *session);

static void stream_got_local_codecs_changed_cb (GabbleMediaStream *stream,

                                                GParamSpec *param,

                                                GabbleMediaSession *session);

static void

_emit_new_stream (GabbleMediaSession *session,

                  GabbleMediaStream *stream)

{

  gchar *object_path;

  guint id, media_type;

  g_object_get (stream,

                "object-path", &object_path,

                "id", &id,

                "media-type", &media_type,

                NULL);

  /* all of the streams are bidirectional from farsight's point of view, it's

   * just in the signalling they change */

  g_signal_emit (session, signals[NEW_STREAM_HANDLER], 0, object_path, id,

      media_type, TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL);

  g_free (object_path);

}

static GabbleMediaStream *

_lookup_stream_by_name_and_initiator (GabbleMediaSession *session,

                                      const gchar *stream_name,

                                      JingleInitiator stream_initiator)

{

  GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  guint i;

  for (i = 0; i < priv->streams->len; i++)

    {

      GabbleMediaStream *stream = g_ptr_array_index (priv->streams, i);

      if (g_strdiff (stream->name, stream_name))

        continue;

      if (stream_initiator != INITIATOR_INVALID &&

          stream_initiator != stream->initiator)

        continue;

      return stream;

    }

  return NULL;

}

static GabbleMediaStream *

create_media_stream (GabbleMediaSession *session,

                     const gchar *name,

                     JingleInitiator initiator,

                     guint media_type)

{

  GabbleMediaSessionPrivate *priv;

  gchar *object_path;

  GabbleMediaStream *stream;

  guint id;

  g_assert (GABBLE_IS_MEDIA_SESSION (session));

  g_assert (name != NULL);

  priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  /* assert that if we're in google mode:

   *  - we only try to make one stream

   *  - it's an audio stream

   *  - it's called GTALK_STREAM_NAME */

  if (priv->mode == MODE_GOOGLE)

    {

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

      g_assert (media_type == TP_MEDIA_STREAM_TYPE_AUDIO);

      g_assert (!g_strdiff (name, GTALK_STREAM_NAME));

    }

  g_assert (priv->streams->len < MAX_STREAMS);

  g_assert (_lookup_stream_by_name_and_initiator (session, name, initiator) ==

      NULL);

  id = _gabble_media_channel_get_stream_id (priv->channel);

  _gabble_media_session_debug (session, DEBUG_MSG_INFO,

      "creating new %s %s stream called \"%s\" with id %u",

      priv->mode == MODE_GOOGLE ? "google" : "jingle",

      media_type == TP_MEDIA_STREAM_TYPE_AUDIO ? "audio" : "video",

      name, id);

  object_path = g_strdup_printf ("%s/MediaStream%u", priv->object_path, id);

  stream = g_object_new (GABBLE_TYPE_MEDIA_STREAM,

                         "connection", priv->conn,

                         "media-session", session,

                         "object-path", object_path,

                         "mode", priv->mode,

                         "name", name,

                         "id", id,

                         "initiator", initiator,

                         "media-type", media_type,

                         NULL);

  g_signal_connect (stream, "notify::connection-state",

                    (GCallback) stream_connection_state_changed_cb,

                    session);

  g_signal_connect (stream, "notify::got-local-codecs",

                    (GCallback) stream_got_local_codecs_changed_cb,

                    session);

  g_ptr_array_add (priv->streams, stream);

  g_free (object_path);

  if (priv->ready)

    _emit_new_stream (session, stream);

  g_signal_emit (session, signals[STREAM_ADDED], 0, stream);

  return stream;

}

static void

destroy_media_stream (GabbleMediaSession *session,

                      GabbleMediaStream *stream)

{

  GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  _gabble_media_stream_close (stream);

  g_ptr_array_remove_fast (priv->streams, stream);

  g_object_unref (stream);

}

static GObject *

gabble_media_session_constructor (GType type, guint n_props,

                                  GObjectConstructParam *props)

{

  GObject *obj;

  GabbleMediaSessionPrivate *priv;

  DBusGConnection *bus;

  obj = G_OBJECT_CLASS (gabble_media_session_parent_class)->

           constructor (type, n_props, props);

  priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (GABBLE_MEDIA_SESSION (obj));

  bus = tp_get_bus ();

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

  return obj;

}

static void

gabble_media_session_get_property (GObject    *object,

                                   guint       property_id,

                                   GValue     *value,

                                   GParamSpec *pspec)

{

  GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);

  GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  switch (property_id) {

    case PROP_CONNECTION:

      g_value_set_object (value, priv->conn);

      break;

    case PROP_MEDIA_CHANNEL:

      g_value_set_object (value, priv->channel);

      break;

    case PROP_OBJECT_PATH:

      g_value_set_string (value, priv->object_path);

      break;

    case PROP_SESSION_ID:

      g_value_set_string (value, priv->id);

      break;

    case PROP_INITIATOR:

      g_value_set_uint (value, session->initiator);

      break;

    case PROP_PEER:

      g_value_set_uint (value, priv->peer);

      break;

    case PROP_PEER_RESOURCE:

      g_value_set_string (value, priv->peer_resource);

      break;

    case PROP_STATE:

      g_value_set_uint (value, priv->state);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void session_state_changed (GabbleMediaSession *session,

                                   JingleSessionState prev_state,

                                   JingleSessionState new_state);

static void

gabble_media_session_set_property (GObject      *object,

                                   guint         property_id,

                                   const GValue *value,

                                   GParamSpec   *pspec)

{

  GabbleMediaSession *session = GABBLE_MEDIA_SESSION (object);

  GabbleMediaSessionPrivate *priv = GABBLE_MEDIA_SESSION_GET_PRIVATE (session);

  JingleSessionState prev_state;

  switch (property_id) {

    case PROP_CONNECTION:

      priv->conn = g_value_get_object (value);

      break;

    case PROP_MEDIA_CHANNEL:

      priv->channel = g_value_get_object (value);

      break;

    case PROP_OBJECT_PATH:

      g_free (priv->object_path);

      priv->object_path = g_value_dup_string (value);

      break;

    case PROP_SESSION_ID:

      g_free (priv->id);

      priv->id = g_value_dup_string (value);

      break;

    case PROP_INITIATOR:

      session->initiator = g_value_get_uint (value);

      break;

    case PROP_PEER:

      priv->peer = g_value_get_uint (value);

      break;

    case PROP_PEER_RESOURCE:

      g_free (priv->peer_resource);

      priv->peer_resource = g_value_dup_string (value);

      break;

    case PROP_STATE:

      prev_state = priv->state;

      priv->state = g_value_get_uint (value);

      if (priv->state == JS_STATE_ENDED)

        g_assert (priv->terminated);

      if (priv->state != prev_state)

        session_state_changed (session, prev_state, priv->state);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void gabble_media_session_dispose (GObject *object);

static void gabble_media_session_finalize (GObject *object);

static void

gabble_media_session_class_init (GabbleMediaSessionClass *gabble_media_session_class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (gabble_media_session_class);

  GParamSpec *param_spec;

  g_type_class_add_private (gabble_media_session_class, sizeof (GabbleMediaSessionPrivate));

  object_class->constructor = gabble_media_session_constructor;

  object_class->get_property = gabble_media_session_get_property;

  object_class->set_property = gabble_media_session_set_property;

  object_class->dispose = gabble_media_session_dispose;

  object_class->finalize = gabble_media_session_finalize;

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

                                    "Gabble connection object that owns this "

                                    "media session's channel.",

                                    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_object ("media-channel", "GabbleMediaChannel object",

                                    "Gabble media channel object that owns this "

                                    "media session object.",

                                    GABBLE_TYPE_MEDIA_CHANNEL,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NICK |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_MEDIA_CHANNEL, param_spec);

  param_spec = g_param_spec_string ("object-path", "D-Bus object path",

                                    "The D-Bus object path used for this "

                                    "object on the bus.",

                                    NULL,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NAME |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_OBJECT_PATH, param_spec);

  param_spec = g_param_spec_string ("session-id", "Session ID",

                                    "A unique session identifier used "

                                    "throughout all communication.",

                                    NULL,

                                    G_PARAM_CONSTRUCT_ONLY |

                                    G_PARAM_READWRITE |

                                    G_PARAM_STATIC_NAME |

                                    G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_SESSION_ID, param_spec);

  param_spec = g_param_spec_uint ("initiator", "Session initiator",

                                  "An enum signifying which end initiated "

                                  "the session.",

                                  INITIATOR_LOCAL,

                                  INITIATOR_REMOTE,

                                  INITIATOR_LOCAL,

                                  G_PARAM_CONSTRUCT_ONLY |

                                  G_PARAM_READWRITE |

                                  G_PARAM_STATIC_NAME |

                                  G_PARAM_STATIC_BLURB);

  g_object_class_install_property (object_class, PROP_INITIATOR, param_spec);

  param_spec = g_param_spec_uint ("peer", "Session peer",

                                  "The GabbleHandle representing the contact "

                                  "with whom this session communicates.",

                                  0, G_MAXUINT32, 0,