/*

* ============================================================================

*  Name        : isoim.c

*  Part of     : isolation server instant messaing componenet.

*  Version     : %version: bh1cfmsg#28 %

*

*  Copyright © 2007-2008 Nokia.  All rights reserved.

*  All rights reserved.

*  Redistribution and use in source and binary forms, with or without modification, 

*  are permitted provided that the following conditions are met:

*  Redistributions of source code must retain the above copyright notice, this list 

*  of conditions and the following disclaimer.Redistributions in binary form must 

*  reproduce the above copyright notice, this list of conditions and the following 

*  disclaimer in the documentation and/or other materials provided with the distribution.

*  Neither the name of the Nokia Corporation nor the names of its contributors may be used 

*  to endorse or promote products derived from this software without specific prior written 

*  permission.

*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 

*  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 

*  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 

*  SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 

*  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

*  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 

*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 

*  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* ============================================================================

* Template version: 1.0

*/

#include "tp-conn-gen.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "isoim.h"

#include "isoutils.h"

#include "msgliterals.h"

#include "msg_enums.h"

/*!	\file 

*	Impliments the functions in isoim.h

*/

/*! /brief requests the handles for the contacts to which message should be sent.

 *  request_handles_cb is registered as a callback. necessary data to be sent is 

 *  passed as userdata 

 *

 *  /param msghdr request header that will be passed back to client

 *  /param contact_id all contacts

 *  /param message

 *  /param no_cntcts  no. of contacts the msg shld be sent to

 *  /return : error code on failure, 0 on success

 */

void send_message( send_msg_struct* msg_hdr,

					const gchar **contact_id ) 

	{

	//request for the handles to contact

	tp_conn_request_handles_async( DBUS_G_PROXY( globalCon.conn ),

						TP_CONN_HANDLE_TYPE_CONTACT,

						contact_id,request_handles_cb, ( gpointer ) msg_hdr );	 							

	}

/*! /brief handles for contacts are recieved and text channel created (if already

 *  there same is used) message is sent to those contacts.

 *  

 *  

 *  /param proxy unused

 *  /param handles contact handles

 *  /param error error if any in getting the handles for contact 

 *  /param userdata Has request header and message to be sent to reciever

 *  The request header is used for mapping of response to correct request

 *

 */

void request_handles_cb(DBusGProxy *proxy, GArray *handles, GError* error, gpointer message)

	{

	TpChan* text_chan = NULL; //for send msg

	guint contact_handle;

	DBusGProxy  *text_iface = NULL;

	send_msg_struct* msg_hdr = ( send_msg_struct* ) message;

	UNUSED_FORMAL_PARAM(proxy);

	//There was error in requesting handles to the contacts

	if ( error )

		{

		iso_logger( "%s", error->message);

		iso_logger( "err code: %d ", error->code );

		//Send error to client

		//What happens if 

		send_response_to_client( msg_hdr->hdr_req,  error->code, 0 );

		g_error_free(error);

		return; 	

		}

	contact_handle = g_array_index( handles, guint, 0 );

	//get the text channel for the contact handle 

	text_chan = g_hash_table_find( globalCon.text_channels,

					      (GHRFunc) text_channels_find_func,

					      &contact_handle);	 

	iso_logger( "text_chan : %d ", text_chan );

	//create a text channel						      

	if ( text_chan == NULL )	

		{

		text_chan = tp_conn_new_channel( globalCon.dbusConn,globalCon.conn,globalCon.connmgr_bus,TP_IFACE_CHANNEL_TYPE_TEXT,

									TP_CONN_HANDLE_TYPE_CONTACT,contact_handle, TRUE );	

		if(!text_chan)

			{

			send_response_to_client( msg_hdr->hdr_req, NOT_CONNECTED , 0 );

			g_error_free(error);

			return;	

			}

		iso_logger( "%s", dbus_g_proxy_get_path(DBUS_G_PROXY(text_chan)));							

		g_hash_table_insert( globalCon.text_channels,g_strdup(dbus_g_proxy_get_path(DBUS_G_PROXY(text_chan))),text_chan);							

		}

	//get interface..	

	text_iface = tp_chan_get_interface( text_chan,TELEPATHY_CHAN_IFACE_TEXT_QUARK );	

	if ( NULL == text_iface ) 

		{

		free( msg_hdr->msg );

		free( msg_hdr->hdr_req );	

		free( msg_hdr );

		//Free proxy ?

		return ;

		}

	//send async

	tp_chan_type_text_send_async( text_iface, TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL, 

		( const char * )msg_hdr->msg,sendreply_cb, msg_hdr->hdr_req ); // see if any user date should be passed

	iso_logger( "Message being sent is %s", msg_hdr->msg ); 	 

	free( msg_hdr->msg );

	free( msg_hdr );

	iso_logger( "%s", "tp_chan_type_text_send_async after\n"); 	

	}

/*! /brief parse the params for send and validates them

 * 

 *  /param aMsgBuffer message buffer to be parsed

 *  /param aContactId pointer to an array of strings, After this function this 

 *  arg wil have the contacts to which message should be sent to

 *  /param aSendMsg message to be sent

 *  /param len : msg_len no. of bytes in aMsgBuffer

 *  /param contact_count : no. of contacts

 *  /return returns error code on failure, or 0

 */

gint parse_for_send( gchar* msg_buf, gchar*** contact_ids, 

			gchar** send_msg, gint msg_len, gint* contact_count ) 

	{

	gchar* users = NULL;

	gint len = 0;

	gint err = 0;

	iso_logger( "%s", "In - parse_for_send\n" );

	//skip the msg_hdr part

	len += sizeof( message_hdr_req );

	//example send message - message header omitted..

	//test.ximp@gmail.com\0ximp.telepathy@gmail.com\0\0hi, how r u?\0

	//					  ^ 						^ ^	            ^ 

	//contact1------------|contact2-----------------|-|message------|

	//gets the contacts, returns no. of contacts on success 

	//error code on error

	err = parse_into_array_of_strings( msg_buf, contact_ids, &len, msg_len,

	 contact_count );

	if ( err < 0 ) 

		{

		//An error has occured, so propagate to next level

		return err;

		}

	/*

	Will never come here.. coz it has been already handled in 

	parse_into_array_of_strings

	if ( *contact_count > MAX_MSG_RECEIPIENTS ) 

		{

		return INVALID_PARAMETERES;

		}*/

	//reset the userlen	

	//parse for the message..

	err = parse_a_string( msg_buf, &users, &len, msg_len );

	if ( err < 0 ) 

		{

		return err; 

		}

	//set the pointer to send message

	*send_msg = users;

	iso_logger( "%s", "Out - parse_for_send\n" );	

	//return the no. of contacts to be sent to	

	return 0;

	}

/*! /brief calls parse_for_send to parse the parameters, and calls 

 *  send_message for sending the message

 * 

 *  /param buf : message buffer to be parsed

 *  /param len : msg_len no. of bytes in msg_buf

 *

 *  /return gint : parse error code if any

 */

int action_parse_send( gchar* buf, gint msg_len ) 

	{

	gchar** contactid = NULL;

	gchar* sendmsg = NULL;

	message_hdr_req *msg_hdr = NULL;

	gint meesage_type_err = 0;

	//It is very imp to initailize the contact_count to 0 here

	gint contact_count = 0;

	send_msg_struct* msg_struct = NULL;

	//parse contacts, message.. 	

	iso_logger( "%s", "In - action_parse_send\n" );

	meesage_type_err = parse_for_send( buf, 

			&contactid,&sendmsg, msg_len, &contact_count );

	//if <= 0 there is some error in the message formation

	if ( contact_count > 0  && meesage_type_err == 0 ) 

		{

		//send message

		msg_hdr = ( message_hdr_req* ) malloc( sizeof( message_hdr_req ) );

		if ( NULL == msg_hdr ) 

			{

			//free resources allocated for this operation

			free_msg_args( contactid, contact_count, sendmsg );

			return MEM_ALLOCATION_ERROR;

			}

	    memset( msg_hdr, '\0', sizeof( message_hdr_req ) );

	    //read message header from buffer

	    memcpy( msg_hdr, buf, sizeof( message_hdr_req ) );

	    //fill the contacts and message into a struct

	    msg_struct = ( send_msg_struct* ) malloc ( sizeof ( send_msg_struct ) );

	    if ( NULL == msg_struct ) 

			{

			free ( msg_hdr );

			free_msg_args( contactid, contact_count, sendmsg );

			return MEM_ALLOCATION_ERROR;

			}

		msg_struct->hdr_req = msg_hdr;

		msg_struct->msg = sendmsg;

		//msg_struct is sent callback... which should be feed there..

		send_message( msg_struct, 

				( const gchar** ) contactid );

		}

	else  

		{

		//there was some error, free resources allocated for this operation

		free_msg_args( contactid, contact_count, sendmsg );

		}

	iso_logger( "%s", "Out - action_parse_send\n" );

	//return error on failure, or no. of contacts message sent to on success

	return meesage_type_err;

	}

/*! /brief Function to check if the channel is already present in the maintained hash

 *  text_channels_find_func. 

 *

 *  /param key unused

 *  /param text_channel hash table element

 *  /param contact_handle to be searched item 

 *  /return boolean 

 */

gboolean text_channels_find_func(	gchar *key,

									TpChan *text_channel,

									guint *contact_handle )

	{

	iso_logger( "%s", "In - text_channels_find_func\n" );

	//Check for the handles

	UNUSED_FORMAL_PARAM(key);

	if ( ( text_channel->handle == *contact_handle ) )

		return TRUE;

	return FALSE;

	} 

/*! /brief Once the send request is sent to n/w server this callback is called

 * 

 *  /param proxy unused

 *  /param error n/w error if any

 *  /param userdata message header from which a response is formed

 *  /return void

 */

void sendreply_cb( DBusGProxy *proxy, GError *error, gpointer userdata ) 

	{

	int err = 0;

	message_hdr_req* msg_hdr = ( message_hdr_req* ) userdata;

	// create the msg queue

	//user data is of type message_hdr_req

	iso_logger( "%s", "In - sendreply_cb\n" );

    UNUSED_FORMAL_PARAM(proxy);

	if ( NULL != error ) 

		{

		//There was some error

		//send the response for the msg_hdr request to client

		err = send_response_to_client( msg_hdr,  error->code, 0 );

		//free the message

		g_error_free(error);

		}

	else 

		{

		//send the response for the msg_hdr request to client

		err = send_response_to_client( msg_hdr, 0, 1 );

		}

	//Free the header recved as callback userdata

	free( msg_hdr );

	if ( err < 0 )

		{

		// failed to delievered	

		return ;

		}

	iso_logger( "%s", "Out - sendreply_cb\n" );

	}

/*! /brief This function is called by tg to as a response to request for the 

 *  handles from the text channel. If there is no error, sent message( 

 *  which has failed ) with its deatils is then sent to client

 * 

 *  /param proxy unused

 *  /param handles_names contac names (sender name)

 *  /param error error if any

 *  /param userdata send_error_struct

 *  /return void

 */     

static void inspect_handles_for_error_cb( DBusGProxy *proxy,char **handles_names,

				 GError *error, gpointer userdata ) 

	{

	gint pri = MSG_PRI_NORMAL;

	gint result = 0;

	gint timeout = NO_WAIT;

	gint err = 0;

	send_error_struct* msg_struct = ( send_error_struct* ) userdata;

	gchar* rmsg = NULL;

	gint index = 0;

	gint len = 0;

	UNUSED_FORMAL_PARAM(proxy);

	iso_logger( "%s", "In - inspect_handles_for_error_cb" );		

	if ( !handles_names || error || NULL == handles_names[0] ) 

		{

		if ( error ) 

			{

			g_error_free( error );	

			}

		//Free the userdata passed to the callback 

		if ( NULL != msg_struct ) 

			{

			if ( msg_struct->msg_body ) 

				{

				g_free( msg_struct->msg_body );		

				}

			g_free( msg_struct );			

			}

		return;

		}

	//Allocate the memory and check for NULL	

	rmsg = ( gchar* ) malloc ( MAX_MSG_SIZE );

	if ( NULL == rmsg ) 

		{

		goto mem_clean;

		}

	//set memory to 0

	memset( rmsg, '\0', MAX_MSG_SIZE );

    //copy the header

    //the response header, message type(from libtp), timestamp

	memcpy( rmsg + index, msg_struct, sizeof( message_hdr_resp )

	+ 2 * sizeof( guint )  );

    index += sizeof( message_hdr_resp ) + 2 * sizeof( guint );

    //Copy the name to whom message was sent

    len = strlen( handles_names[0] );

    strcpy( rmsg + index, handles_names[0] );

    index += len + 1;

    //Copy the message body

    if ( msg_struct->msg_body ) 

	    {

	    len = strlen( msg_struct->msg_body );

	    strcpy( rmsg + index, msg_struct->msg_body );

	    index += len + 1;	   	

	    }

    rmsg[index++] = '\0';

    //Header format

    //msgHdr|msg_type|timestamp|reciepient_name\0sent_msg\0

	// 		^                                   ^         ^

    //      |			                        |		  |

    //no dilimeter here                        nul		 nul

    //send to the client

    result = MsgQSend( RESPONSE_QUEUE, rmsg, index, 

						pri, timeout, &err );

	iso_logger( "%s", "After MsgQSend" );						

//If memory allocation for rmsg has failed control comes

//here

mem_clean:

	for ( len = 0; handles_names[len]; len++ )	

		{

		free ( handles_names[len] );

		}

	if ( msg_struct->msg_body ) 

		{

		g_free( msg_struct->msg_body );		

		}

	g_free( msg_struct );

	if ( result < 0 )

		{

		//Failed to deliver the message

		iso_logger( "%s", "Failed to deliver the message to client" );

		return;

		}

	iso_logger( "%s", "Out - inspect_handles_for_error_cb" );

	}

/*! /brief This function on registered for "senderror" signal is called when the message 

 *  sending is failed. Calls tp_conn_inspect_handles_async to get the contact name 

 *  from text channel

 *

 *  /param proxy : unused

 *  /param error : error code

 *  /param timestamp : sent to inspect_handles_for_error_cb thru' send_error_struct

 *  /param message_type : sent to inspect_handles_for_error_cb thru' send_error_struct

 *  /param message_body : sent to inspect_handles_for_error_cb thru' send_error_struct

 *  /param user_data text_chan from where to get the contatc name of reciepien

 *  /return void

 */

static void senderror_cb (  DBusGProxy *proxy,

								guint            error,

							   	guint            timestamp,

							    guint            message_type,

							    gchar           *message_body,

							    gpointer		user_data )

	{

	TpChan *text_chan = ( TpChan * ) user_data;

	send_error_struct* msg_struct = NULL;

	GArray* fetch_members = NULL;

	DBusGProxyCall* call_id = NULL;

	//Logs

	iso_logger( "%s", "In - SendError_cb\n" );

	iso_logger( "error is %d", error );

	iso_logger( "error is %d", message_type );

	iso_logger( "error is %d", timestamp );

	iso_logger( "error is %s", message_body );

	UNUSED_FORMAL_PARAM(proxy);

	//Allocate memory and check for NULL

	//This msg_struct is passed to callback..

	//So not deleting here.. ownership is transfered

	msg_struct = ( send_error_struct* ) malloc ( sizeof( send_error_struct ) );

	if ( NULL == text_chan || NULL == msg_struct ) 

		{

		return;

		}

	//Set the values to NULL		

	memset( msg_struct, '\0', sizeof( send_error_struct ) );

	//Message type is send error

	msg_struct->hdr_resp.hdr_req.message_type = ESend_Error;

	//other values are set to 0

	msg_struct->hdr_resp.hdr_req.protocol_id = 0;

	msg_struct->hdr_resp.hdr_req.session_id = 0;

	msg_struct->hdr_resp.hdr_req.request_id = 0;

	//Message is sent as single entity..

	//Message is not long enough to be broken into 

	msg_struct->hdr_resp.continue_flag = 0;

	msg_struct->hdr_resp.response = 0;

	//Set the error type

	msg_struct->hdr_resp.error_type = error;

	//Set the values from libtelepathy

	msg_struct->msg_type = message_type;

	msg_struct->timestamp = timestamp;

	//Not checking for NULL here.. 

	//I feel it is ok to send without the message 

	//Taken care of this in inspect_handles_for_error_cb

	msg_struct->msg_body = strdup( message_body );

	//Create an array of handles to get the handle name

	fetch_members = g_array_new ( FALSE, FALSE, sizeof ( guint32 ) );

	g_array_append_val( fetch_members, text_chan->handle );

	//Call libtp function to get the contact name for the handle

	//msg_struct is passed to inspect handles call back to be passed to 

	//client as error

	call_id = tp_conn_inspect_handles_async( DBUS_G_PROXY( globalCon.conn ),

					       TP_CONN_HANDLE_TYPE_CONTACT ,fetch_members,

					       inspect_handles_for_error_cb, msg_struct );

	g_array_free( fetch_members, TRUE );

	if ( NULL == call_id )

		{

		return ;

		}

	iso_logger( "%s", "Out - SendError_cb" );

	}