/*

* Copyright (c) 2008 - 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    Used for Send/Receive Test Cases

*

*/

//Include files

#include <e32err.h>

#include <e32const.h>

#include <e32base.h>

#include <glib.h>

#include <StifLogger.h>

#include "telepathygabbleutils.h"

#include "telepathygabblesendmessage.h"

#include "telepathygabbletestdata.h"

//-----------------------------------------------------------------------------

// function_name	: CTelepathyGabbleSendRecvMessage

// description     	: constructor

//----------------------------------------------------------------------------- 

CTelepathyGabbleSendRecvMessage::CTelepathyGabbleSendRecvMessage()

{

}

//-----------------------------------------------------------------------------

// function_name	: ConstructL

// description     	: constructor

//----------------------------------------------------------------------------- 

void CTelepathyGabbleSendRecvMessage::ConstructL()

{

}

//-----------------------------------------------------------------------------

// function_name	: NewL

// description     	: NewL

//----------------------------------------------------------------------------- 

CTelepathyGabbleSendRecvMessage* CTelepathyGabbleSendRecvMessage::NewL()

    {

	CTelepathyGabbleSendRecvMessage* self = new(ELeave) CTelepathyGabbleSendRecvMessage;

    CleanupStack::PushL( self );

    self->ConstructL();    

    CleanupStack::Pop();

    return self;

    }

//-----------------------------------------------------------------------------

// function_name	:  ~CTelepathyGabbleSendRecvMessage

// description     	: Destructor

//----------------------------------------------------------------------------- 

CTelepathyGabbleSendRecvMessage::~CTelepathyGabbleSendRecvMessage()

    {

    }

//-----------------------------------------------------------------------------

// function_name	: SendMessage

// description     	: To send a message

//----------------------------------------------------------------------------- 

TInt CTelepathyGabbleSendRecvMessage::SendMessage( const char *contact_id, 

													const char *message,

													CTestData* aTestData )

{

	TpChan* text_chan = NULL; //for send msg

	TInt contact_handle;

	GArray *handles = NULL;

	GError* error = NULL;

	DBusGProxy  *text_iface = NULL;

	gpointer userdata = NULL; 

	//get the contact handle.

	contact_handle =  CTelepathyGabbleUtils::get_handle_from_contact(contact_id,aTestData);

	if ( contact_handle == KErrNotFound )

		{

		return CTestData::EMessageSendErr;	

		}

	text_chan = (TpChan*)g_hash_table_find(

								   aTestData->GetTextChannelsHT(),

							      (GHRFunc) text_channels_find_func,

							      &contact_handle );	 

	//text_chan for the particular contact does not exist.

	//New text_chan must be created.						      

	if (text_chan == NULL)	

		{ 

		text_chan = tp_conn_new_channel(

							(aTestData->GetDBusConnection()),

							(aTestData->GetTpConn()),CONNMGR_BUS,TP_IFACE_CHANNEL_TYPE_TEXT,

							TP_CONN_HANDLE_TYPE_CONTACT,contact_handle, TRUE );	

		//Insert the new text_chan to the hash table.							

		g_hash_table_insert(

				(aTestData->GetTextChannelsHT()),

				g_strdup(dbus_g_proxy_get_path(DBUS_G_PROXY(text_chan))),text_chan);

		}

	text_iface = tp_chan_get_interface(text_chan,TELEPATHY_CHAN_IFACE_TEXT_QUARK);	

	if( aTestData->GetTestType() == CTestData::ESendErr ||

		aTestData->GetTestType() == CTestData::EReceive )

		{

		//Register the callback to get the error

		//when the recipeint_id is invalid.

		dbus_g_proxy_connect_signal(text_iface, "SendError",

					G_CALLBACK(SendError_cb),

						aTestData, NULL);	

		}

	if( aTestData->GetTestType() == CTestData::EReceive )

		{

		//Register for the receive message callback here.

	 	dbus_g_proxy_connect_signal(text_iface, "Received",

					(G_CALLBACK(receivedMessage_cb)),

					aTestData, NULL);	

		}

	//This callback tells whether the message is sent to the server or not.

	tp_chan_type_text_send_async( text_iface, TP_CHANNEL_TEXT_MESSAGE_TYPE_NORMAL, 

	message,sendmessage_cb, aTestData); 

	// user_data = this i.e. the class pointer  

	//Run the mainloop

	g_main_loop_run (aTestData->GetMainLoop());

	//return the Message_sent that was updated in the callback sendmessage_cb	

	return aTestData->GetSendRecvMsgState();

}

//-----------------------------------------------------------------------------

// function_name	: ReceiveMessage

// description     	: receive message

//----------------------------------------------------------------------------- 

TInt CTelepathyGabbleSendRecvMessage::ReceiveMessage(   const char *contact_id,

														const char *message,

														CTestData* aTestData )

{

	TpChan* text_chan = NULL; //for send msg

	DBusGProxy *text_iface;

	guint contact_handle;

	//send msg 1

	//For Automation, Do the send message to yourself

	//own contact_id received from the cfg file.

	TInt msg_status = SendMessage(contact_id,message,aTestData);

	if( msg_status == CTestData::EMessageNotSent )

		{

			aTestData->GetStifLogger()->Log( _L("ReceiveMessage: Msg is not sent successfully \n") );

		    if( aTestData->GetTestType() == CTestData::ERecvBlank )

		    	g_main_loop_quit(aTestData->GetMainLoop()); 

			return CTestData::EMessageNotSent;

		}

 	/*contact_handle =  CTelepathyGabbleUtils::get_handle_from_contact(contact_id,aTestData);

 	text_chan = (TpChan*)g_hash_table_find(

 					(aTestData->GetTextChannelsHT()),

				      (GHRFunc) text_channels_find_func,

				      &contact_handle );	

    text_iface = tp_chan_get_interface(text_chan ,

					   TELEPATHY_CHAN_IFACE_TEXT_QUARK);

 	//Register for the receive message callback here.

 	dbus_g_proxy_connect_signal(text_iface, "Received",

				(G_CALLBACK(receivedMessage_cb)),

				aTestData, NULL);

 	//send msg 2

 	//Do the send message to yourself

	msg_status == CTestData::EMessageNotSent )

		{

			return CTestData::EMessageNotSent;

		}*/

	aTestData->GetStifLogger()->Log( _L("after : register receivedMessage_cb \n") );

	if (aTestData->GetTestType() == CTestData::EReceive && 

			aTestData->GetSendRecvMsgState() != CTestData::EMessageSendErr )

	{

		//there are two callbacks now.

		//receivedMessage_cb and sendmessage_cb.

		//Run the mainloop again as it was quit in the callback sendmessage_cb.

		//the message_state is not yet MESSAGE_RECEIVED.

		//we need to start the main loop again to get the receivedmessage_cb.

		aTestData->GetStifLogger()->Log( _L("start mainloop if state not as EMESSAGE_RCVD \n") );

 		g_main_loop_run (aTestData->GetMainLoop());

 	}

  return aTestData->GetSendRecvMsgState();

}

//-----------------------------------------------------------------------------

// function_name	: sendmessage_cb

// description     	: Callback for Send Message

//----------------------------------------------------------------------------- 

void CTelepathyGabbleSendRecvMessage::sendmessage_cb( DBusGProxy* /*proxy*/, GError* /*error*/, gpointer userdata ) 

{

	CTestData* testdata = static_cast<CTestData*> (userdata);

	testdata->GetStifLogger()->Log( _L("inside sendmessage_cb \n") );

 	//This is the test case for sending message to invalid userid.

 	if ( testdata->GetTestType() != CTestData::ESendErr )

 	{

		testdata->SetSendRecvMsgState(CTestData::EMessageSent);

		testdata->GetStifLogger()->Log( _L("sendmessage_cb::msg sent successfully \n") );

 		//Quit the main loop , just for now

 		g_main_loop_quit(testdata->GetMainLoop()); 

 	}

 	else if( testdata->GetTestType() == CTestData::ERecvBlank )

 	{

 		//Quit the main loop , just for now

 		testdata->GetStifLogger()->Log( _L("sendmessage_cb::test case is for blank msg sending \n") );

 		g_main_loop_quit(testdata->GetMainLoop()); 	

 	}

 	//otherwise send message error test case, dont quit.

}

//-----------------------------------------------------------------------------

// function_name	: receivedMessage_cb

// description     	: Callback for receive message

//----------------------------------------------------------------------------- 

void CTelepathyGabbleSendRecvMessage::receivedMessage_cb (  DBusGProxy* /*proxy*/,

								guint            /* message_id */,

							   	guint            /* timestamp */,

							    guint           /* from_handle */,

							    guint           /* message_type */,

							    guint           /* message_flags */,

							    gchar           * /*message_body */,

							    gpointer		user_data )

{

	//GArray  *message_ids;

	//GArray  *handles = NULL;

	CTestData* testdata = static_cast<CTestData*> (user_data);

	/*message_ids = g_array_new (FALSE, FALSE, sizeof (guint));

	g_array_append_val (message_ids, message_id);

	g_array_free (message_ids, TRUE);

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

	g_array_append_val (handles, from_handle);	

	g_array_free (handles, TRUE);*/

	testdata->GetStifLogger()->Log( _L("receivedMessage_cb::test case is for receive msg \n") );

	if( testdata->GetTestType() == CTestData::EReceive )

		{

		testdata->SetSendRecvMsgState(CTestData::EMessageRecvd);

		//Quit the main loop once the receive message callback is received. 	

	 	g_main_loop_quit(testdata->GetMainLoop());

		}

}

//-----------------------------------------------------------------------------

// function_name	: text_channels_find_func

// description     	: find whether the text channel 

//										is existing given the hash table pointer

//----------------------------------------------------------------------------- 

gboolean CTelepathyGabbleSendRecvMessage::text_channels_find_func(	gchar* /*key*/,

									TpChan *text_channel_ht_ptr,

									guint *contact_handle)

{

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

	{

		return TRUE;

	}//else

	return FALSE;

} 

void CTelepathyGabbleSendRecvMessage::SendError_cb (  DBusGProxy* /*proxy*/,

								guint            error,

							   	guint            /*timestamp*/,

							    guint            /*message_type*/,

							    gchar*           /*message_body*/,

							    gpointer		user_data )

{

	//Get the testdata

	CTestData* testdata = static_cast<CTestData*> (user_data);

	FILE* fp;

	fp = fopen("c:\\testlogs.txt","a");

	if(fp)

	{

		fprintf(fp,"error  code is %u", error);

		fprintf(fp,"\n");

		fclose(fp);

	}

	testdata->GetStifLogger()->Log( _L("inside SendError_cb \n") );

	testdata->SetSendRecvMsgState(CTestData::EMessageSendErr);		

  	//quit the main loop

  	g_main_loop_quit(testdata->GetMainLoop());	

}