/*

 * libgabble_wsd.cpp part of telepathygabble

 * Copyright (C) 2006 Collabora Ltd.

 * 

 *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>

 *   @author Robert McQueen <robert.mcqueen@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 <e32std.h> 

#include "libgabble_wsd_solution.h"

#include "gabble_enums.h"

#include <string.h>

#include "telepathy-interfaces.h"

#include <pls.h> // For emulator WSD API 

const TUid KLibGabbleUid3 = {0x2000F852};     // This is the UID of the library

struct libgabble_global_struct *libgabble_ImpurePtr()

{

	#if defined(__WINSCW__) || defined(__WINS__)

	// Access the PLS of this process

	struct libgabble_global_struct *g = Pls<struct libgabble_global_struct>(KLibGabbleUid3, &libgabble_Init);	

    return g;

	#else

	return NULL;	

	#endif

}

int libgabble_Init(libgabble_global_struct *g)

{

Handler handlers[10] = {

  {

    { "initiate", "session-initiate", NULL },

    JS_STATE_PENDING_CREATED,

    JS_STATE_PENDING_CREATED,

    { NULL },

    JS_STATE_PENDING_INITIATED

  },

  {

    { "accept", "session-accept", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_PENDING_INITIATED,

    { NULL },

    JS_STATE_ACTIVE

  },

  {

    { "reject", NULL },

    JS_STATE_PENDING_INITIATE_SENT,

    JS_STATE_PENDING_INITIATED,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { "terminate", "session-terminate", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_ENDED,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { "candidates", "transport-info", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_ACTIVE,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { "content-add", NULL },

    JS_STATE_ACTIVE,

    JS_STATE_ACTIVE,

    { NULL },

    JS_STATE_INVALID,

  },

  {

    { "content-modify", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_ACTIVE,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { "content-accept", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_ACTIVE,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { "content-remove", "content-decline", NULL },

    JS_STATE_PENDING_INITIATED,

    JS_STATE_ACTIVE,

    { NULL },

    JS_STATE_INVALID

  },

  {

    { NULL },

    JS_STATE_INVALID,

    JS_STATE_INVALID,

    { NULL },

    JS_STATE_INVALID

  }

};

GDebugKey keys[] = {

  { "presence",      GABBLE_DEBUG_PRESENCE },

  { "groups",        GABBLE_DEBUG_GROUPS },

  { "roster",        GABBLE_DEBUG_ROSTER },

  { "disco",         GABBLE_DEBUG_DISCO },

  { "properties",    GABBLE_DEBUG_PROPERTIES },

  { "roomlist",      GABBLE_DEBUG_ROOMLIST },

  { "media-channel", GABBLE_DEBUG_MEDIA },

  { "muc",           GABBLE_DEBUG_MUC },

  { "connection",    GABBLE_DEBUG_CONNECTION },

  { "persist",       GABBLE_DEBUG_PERSIST },

  { "vcard",         GABBLE_DEBUG_VCARD },

  { 0, },

};

gchar NO_ALIAS[10] = "none";

gchar assumed_caps[3][150] =

{

  TP_IFACE_CHANNEL_TYPE_TEXT,

  TP_IFACE_CHANNEL_INTERFACE_GROUP,

  NULL

};

gchar muc_roles[4][20] =

{

  "none",

  "visitor",

  "participant",

  "moderator",

};

gchar muc_affiliations[4][20] =

{

  "none",

  "member",

  "admin",

  "owner",

};

gchar video_codec_params[6][20] = {

  "x", "y", "width", "height", "layer", "transparent",

};

char list_handle_strings[4][20] =

{

    "publish",      /* GABBLE_LIST_HANDLE_PUBLISH */

    "subscribe",    /* GABBLE_LIST_HANDLE_SUBSCRIBE */

    "known",        /* GABBLE_LIST_HANDLE_KNOWN */

    "deny"          /* GABBLE_LIST_HANDLE_DENY */

};

	  if(g)

	  {	

		//g->GET_WSD_VAR_NAME(flags,gabble_debug,s) = flags;

		g->GET_WSD_VAR_NAME(log_handler, gabble_debug, s)	= 0;

		g->GET_WSD_VAR_NAME(etype,gabble_enum_types,s) = 0;

		g->GET_WSD_VAR_NAME(etype,gabble_media_session_enum_types,s) = 0;

		g->GET_WSD_VAR_NAME(etype1,gabble_media_session_enum_types,s) = 0;

		g->GET_WSD_VAR_NAME(etype2,gabble_media_session_enum_types,s) = 0;

		g->GET_WSD_VAR_NAME(quark,gabble_disco,s) = 0; 

		g->GET_WSD_VAR_NAME(quark,gabble_error,s) = 0;

		g->GET_WSD_VAR_NAME(ssl,gabble_conmgr,s) = TRUE; 

		g->GET_WSD_VAR_NAME(httpport,gabble_conmgr,s) = 8080;

		g->GET_WSD_VAR_NAME(httpproxyport,gabble_conmgr,s) = 443;

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_conmgr,s)),0,LAST_SIGNAL_CON_MGR*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_con,s)),0,LAST_SIGNAL_CON*sizeof(guint));	  

		g->GET_WSD_VAR_NAME(arguments,gabble_con, s) = NULL;

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_im,s)),0,LAST_SIGNAL_IM*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_search,s)),0,LAST_SIGNAL_SEARCH*sizeof(guint));	   

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_muc,s)),0,LAST_SIGNAL_MUC*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_med_chnl,s)),0,LAST_SIGNAL_MED_CHANNEL*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_med_sess,s)),0,LAST_SIGNAL_MED_SESSION*sizeof(guint));	  

		g->GET_WSD_VAR_NAME(google_audio_caps,gabble_med_sess,s) = PRESENCE_CAP_GOOGLE_VOICE;

		int some = PRESENCE_CAP_JINGLE | PRESENCE_CAP_JINGLE_DESCRIPTION_AUDIO |

		    PRESENCE_CAP_GOOGLE_TRANSPORT_P2P;

		g->GET_WSD_VAR_NAME(jingle_audio_caps,gabble_med_sess,s) = (GabblePresenceCapabilities)some;

		some = PRESENCE_CAP_JINGLE | PRESENCE_CAP_JINGLE_DESCRIPTION_VIDEO |

		    PRESENCE_CAP_GOOGLE_TRANSPORT_P2P;

		g->GET_WSD_VAR_NAME(jingle_video_caps,gabble_med_sess,s) = 

		(GabblePresenceCapabilities) some;

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_med_sess,s)),0,MAX_STREAM_NAME_LEN*sizeof(gchar));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_med_stream,s)),0,LAST_SIGNAL_MED_STREAM*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_pre_cache,s)),0,LAST_SIGNAL_PRE_CACHE*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_register,s)),0,LAST_SIGNAL_REGISTER*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_ros_chnl,s)),0,LAST_SIGNAL_ROS_CHNL*sizeof(guint));	  

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_room_chnl,s)),0,LAST_SIGNAL_ROOM_CHNL*sizeof(guint));	  

		g->GET_WSD_VAR_NAME(offset_quark1,gabble_mixin,s) = 0;

		g->GET_WSD_VAR_NAME(offset_quark,gabble_mixin,s) = 0;

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_roster,s)),0,LAST_SIGNAL_ROSTER*sizeof(guint));	  

		g->GET_WSD_VAR_NAME(quark,gabble_errors,s) = 0;

		g->GET_WSD_VAR_NAME(busCon,gabble_helpers,s) = NULL;

		g->GET_WSD_VAR_NAME(bus_proxy,gabble_helpers,s) = NULL;

		g->GET_WSD_VAR_NAME(offset_quark1,gabble_txt_mixin,s) = 0;

		g->GET_WSD_VAR_NAME(offset_quark,gabble_txt_mixin,s) = 0;

		memset(&(g->GET_WSD_VAR_NAME(alloc1,gabble_txt_mixin,s)),0,sizeof(GabbleAllocator));	  	

		g->GET_WSD_VAR_NAME(type,gabble_chnl_iface,s) = 0;

		g->GET_WSD_VAR_NAME(initialized,gabble_chnl_iface,s) = EFalse;    

		g->GET_WSD_VAR_NAME(type,gabble_fac_iface,s) = 0;

		g->GET_WSD_VAR_NAME(initialized,gabble_fac_iface,s) = EFalse;	

		memset(&(g->GET_WSD_VAR_NAME(signals,gabble_vcard_mgr,s)),0,LAST_SIGNAL_VCARD_MGR*sizeof(guint));	  

		g->GET_WSD_VAR_NAME(quark1,gabble_vcard_mgr,s) = 0;

		g->GET_WSD_VAR_NAME(quark2,gabble_vcard_mgr,s) = 0;

		g->GET_WSD_VAR_NAME(offset_quark1,gabble_grp_mixin,s) = 0;

		g->GET_WSD_VAR_NAME(offset_quark,gabble_grp_mixin,s) = 0;	    

		g->GET_WSD_VAR_NAME(gabble_disco_parent_class,gabble_disco,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_disco,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_connection_manager_parent_class,gabble_conmgr,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_conmgr,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_connection_parent_class,gabble_con,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_con,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_im_channel_parent_class,gabble_im,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_im,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_search_channel_parent_class,gabble_search,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_search,s) = 0;

       	g->GET_WSD_VAR_NAME(gabble_muc_channel_parent_class,gabble_muc,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_muc,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_media_channel_parent_class,gabble_med_chnl,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_med_chnl,s) = 0;

	    g->GET_WSD_VAR_NAME(gabble_media_stream_parent_class,gabble_med_stream,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_med_stream,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_presence_parent_class,gabble_presence,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_presence,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_presence_cache_parent_class,gabble_pre_cache,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_pre_cache,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_register_parent_class,gabble_register,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_register,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_roster_channel_parent_class,gabble_ros_chnl,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_ros_chnl,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_roomlist_channel_parent_class,gabble_room_chnl,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_room_chnl,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_im_factory_parent_class ,im_factory,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,im_factory,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_media_factory_parent_class ,media_factory,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,media_factory,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_muc_factory_parent_class ,muc_factory,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,muc_factory,s) = 0;

        g->GET_WSD_VAR_NAME(gabble_vcard_manager_parent_class ,gabble_vcard_mgr,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_vcard_mgr,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_media_session_parent_class ,gabble_med_sess,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_med_sess,s) = 0;

		g->GET_WSD_VAR_NAME(gabble_roster_parent_class ,gabble_roster,s) = ((void *)0); 

		g->GET_WSD_VAR_NAME(g_define_type_id,gabble_roster,s) = 0;

	    memcpy (&(g->GET_WSD_VAR_NAME(keys,gabble_debug,s)), keys, 12*sizeof(GDebugKey));

	  	strcpy((g->GET_WSD_VAR_NAME(NO_ALIAS,gabble_vcard_mgr,s)), NO_ALIAS);

	  	memset(&(g->GET_WSD_VAR_NAME(assumed_caps,gabble_con,s)),0,3*150*sizeof(gchar));

	  	strcpy((g->GET_WSD_VAR_NAME(assumed_caps,gabble_con,s))[0], assumed_caps[0]);

	  	strcpy((g->GET_WSD_VAR_NAME(assumed_caps,gabble_con,s))[0], assumed_caps[1]);

	  	strcpy((g->GET_WSD_VAR_NAME(muc_roles,gabble_muc,s))[0], muc_roles[0]);

	  	strcpy((g->GET_WSD_VAR_NAME(muc_roles,gabble_muc,s))[1], muc_roles[1]);

	  	strcpy((g->GET_WSD_VAR_NAME(muc_roles,gabble_muc,s))[2], muc_roles[2]);

	  	strcpy((g->GET_WSD_VAR_NAME(muc_roles,gabble_muc,s))[3], muc_roles[3]);

		strcpy((g->GET_WSD_VAR_NAME(muc_affiliations,gabble_muc,s))[0], muc_affiliations[0]);

		strcpy((g->GET_WSD_VAR_NAME(muc_affiliations,gabble_muc,s))[1], muc_affiliations[1]);

		strcpy((g->GET_WSD_VAR_NAME(muc_affiliations,gabble_muc,s))[2], muc_affiliations[2]);

		strcpy((g->GET_WSD_VAR_NAME(muc_affiliations,gabble_muc,s))[3], muc_affiliations[3]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[0], video_codec_params[0]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[1], video_codec_params[1]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[2], video_codec_params[2]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[3], video_codec_params[3]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[4], video_codec_params[4]);

		strcpy((g->GET_WSD_VAR_NAME(video_codec_params,gabble_med_stream,s))[5], video_codec_params[5]);

		strcpy((g->GET_WSD_VAR_NAME(list_handle_strings,handles,s))[0], list_handle_strings[0]);

		strcpy((g->GET_WSD_VAR_NAME(list_handle_strings,handles,s))[1], list_handle_strings[1]);

		strcpy((g->GET_WSD_VAR_NAME(list_handle_strings,handles,s))[2], list_handle_strings[2]);

		strcpy((g->GET_WSD_VAR_NAME(list_handle_strings,handles,s))[3], list_handle_strings[3]);

		memcpy (&(g->GET_WSD_VAR_NAME(handlers,gabble_med_sess,s)), handlers, 10*sizeof(Handler));

		return 0;

  }

  return 1;

}