/*

* Copyright (c) 2007 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:  

*

*/

#include <e32base.h>

#include <e32def.h>

#include <msvapi.h>

#include <msvids.h>

#include <cmsvattachment.h>

#include "messageheader.h"

#include "messagingservice.h"

#include "messaginginterface.h"

#include "serviceerrno.h"

using namespace LIW;

_LIT8(KErrorCode,		"ErrorCode");

_LIT8(KTransactionID,	"TransactionID");

_LIT8(KReturnValue,		"ReturnValue");

_LIT8(KContentType,		"Type");

// Messaging Command Names

_LIT8(KCmdSendMessage,		"Send");

_LIT8(KCmdGetHeaderList,	"GetList");

_LIT8(KCmdRegNotification,	"RegisterNotification");

_LIT8(KCmdCancelNotification,"CancelNotification");

_LIT8(KCmdDeleteMsg,		"Delete");

_LIT8(KCmdChangeStatus,		"ChangeStatus");

_LIT8(KCmdCancel,			"Cancel");

// Send Message Parameters

_LIT8(KMessageParam, 		"MessageParam");

_LIT8(KMtm, 				"MessageType");

_LIT8(KTemplateId,  		"TemplateId");

_LIT8(KSubject,  			"Subject");

_LIT8(KBodyText,  			"BodyText");

_LIT8(KLaunchEditor,		"LaunchEditor");

_LIT8(KRecipientTo,  		"To");

_LIT8(KRecipientToElement,  "To List Element");

_LIT8(KRecipientCc,  		"Cc");

_LIT8(KRecipientCcElement,  "Cc List Element");

_LIT8(KRecipientBcc,  		"Bcc");

_LIT8(KAttachmentName, 		"Attachment");

_LIT8(KRecipientBccElement, "Bcc List Element");

_LIT8(KAttachmentList, 		"AttachmentList");

_LIT8(KAttachmentListElement,"AttachmentList Element");

_LIT8(KAttachmentType,		"AttachmentType" );

_LIT8(KFileName, 			"FileName" );

_LIT8(KMimeType, 			"MimeType" );

_LIT(KAttachmentFile,		"File" );

_LIT(KAttachmentLinkedFile,	"LinkedFile" );

// Header List Input Parameters

_LIT8(KFilter,				"Filter" );

_LIT8(KSortOrder,			"SortOrder" );

_LIT8(KField,				"Key");

_LIT8(KOrder,				"Order");

_LIT(KSortByDate,			"Date" );

_LIT(KSortBySize,			"Size" );

_LIT(KSortBySender,			"Sender" );

_LIT(KSortBySubject,		"Subject" );

_LIT(KSortById,				"MessageId" );

_LIT(KSortAsc,				"Ascending" );

_LIT(KSortDec,				"Descending" );

_LIT8(KSenderList, 			"SenderList");

_LIT8(KMtmList,				"MessageTypeList" );

_LIT8(KSenderElement, 		"SenderList Number");

_LIT8(KMtmElement,			"MessageTypeList Element" );

_LIT8(KMessageId, 			"MessageId");

_LIT8(KStartDate,			"StartDate" );

_LIT8(KEndDate,				"EndDate" );

// Header List Output Parameters

_LIT8(KUnreadFlag, 			"Unread");

_LIT8(KAttachFlag, 			"Attachment");

_LIT8(KPriority, 			"Priority");

_LIT8(KTime, 				"Time");

// Message detail Output Parameters

_LIT8(KSender,  			"Sender");

_LIT8(KFileSize, 			"FileSize" );

_LIT8(KFileHandle, 			"FileHandle" );

// Change status parameters

_LIT8(KStatus,				"Status");

_LIT(KInbox,				"Inbox");

_LIT(KStatusFlagRead,		"Read");

_LIT(KStatusFlagUnread,		"Unread");

_LIT(KStatusFlagReplied,	"Replied");

_LIT(KStatusFlagForward,	"Forwarded");

_LIT(KStatusFlagDeleted,	"Deleted");

// New Message Notification Parameters

_LIT8(KNotificationType,	"Type");

_LIT(KNotificationNewMsg,	"NewMessage");

//ErrorMessages

_LIT8( KErrorMessage, "ErrorMessage"); 

const TInt KMaxMsgSize = 256;

_LIT(KDomainName,"Messaging");

_LIT(KErrorMsgSeparator,":");

_LIT( KIncorrectValue, " Value Incorrect" );

_LIT( KDateMismatch, " Start Date greater than EndDate in Filter" );

_LIT( KTypeInvalid, " Type Invalid" );

_LIT( KMissing, " Missing" );

_LIT( KErrMsgMissingLiwCancel, "Liw Cancel Options Not Set" );

_LIT( KInvalidCallbackSetup, "Insufficent argument for asynchronous request" );

_LIT( KInvalidCMD, "Command not supported");

_LIT( KAsyncNotSupported,"Asynchronous Operation not supported" );

_LIT( KSyncNotSupported,"Synchronous Operation not supported" );

void UpdateOutputAsHeaderL( CLiwGenericParamList* aOutParamList, TAny* aResult );

void UpdateOutputAsIdListL( CLiwGenericParamList* aOutParamList, 

										CMsvEntrySelection* aEntrySelection, 

										CMessagingService* aMsgService,

										CFilterParamInfo* aFilter );

void UpdateMessageDetailToMapL( CLiwMap* aResultMap, CMessageDetailInfo* aMessageDetail );

TBool GetLiwHeaderL( CMessageHeader* aHeader, 

										TLiwVariant& aElement, 

										CMessagingService* aMsgService = NULL, 

										TBool aCustomMap = EFalse );

TInt32 ErrCodeConversion(TInt code);

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

// Check the Type of Liw variant... whether they match or not....

// If they dont match leave 

// If source is of nullvariant type then leave only if aLeaveflag is set

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

//

TBool CMessagingInterface::CheckInputTypeL( const TLiwVariant* aSource, 

                                            TBool aLeaveFlag, 

                                            LIW::TVariantTypeId aExpectedtype, 

                                            const TDesC8& aCmdName, 

											const TDesC8& aParameter,

											const TDesC& aMessage )

	{

	if ( aSource->TypeId() == aExpectedtype )

	    {

	    return ETrue;

	    }

	else if ( ( aSource->TypeId() != LIW::EVariantTypeNull ) || aLeaveFlag )

		{

		AppendErrorMessageL( aCmdName, aParameter, aMessage, 0 );

		((TLiwVariant*)aSource)->Reset();

		User::Leave( KErrBadName );

		}	

	return EFalse;

	}

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

// Append Error Message

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

//

void CMessagingInterface::AppendErrorMessageL( const TDesC8& aCmdName, 

											   const TDesC8& aParameter, 

											   const TDesC& aMessage,

											   TInt aNoneOrMissingOrIncorrect )

	{

	iErrorMessage = HBufC::NewL( KMaxMsgSize );

	TPtr tmpMsgPtr = iErrorMessage->Des();

	tmpMsgPtr.Copy(KDomainName);

	HBufC* temp = HBufC::New( KMaxMsgSize );

	if ( aCmdName.Length() )

		{

		tmpMsgPtr.Append( KErrorMsgSeparator );

		temp->Des().Copy( aCmdName ); 

		tmpMsgPtr.Append( temp->Des() );

		}

	tmpMsgPtr.Append(KErrorMsgSeparator);

	if ( aParameter.Length() )

		{

		temp->Des().Copy(aParameter); 

		tmpMsgPtr.Append(temp->Des());

		}

	if ( aMessage.Length() )

		{

		tmpMsgPtr.Append( aMessage );

		}

    delete temp;

	switch( aNoneOrMissingOrIncorrect )

		{

		case 1:

		        User::Leave(SErrMissingArgument);

		case 2:

		        User::Leave(KErrArgument);

		default:		        

		        break;

		}	

	}

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

// Function called from sync APIs to check whether Async set up is done if yes then leaves

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

//

inline void CMessagingInterface::LeaveIfAsynchronousL( TUint aCmdOptions,

	 				          					MLiwNotifyCallback* aCallback,

					          				    const TDesC8& aCmdName, 

											    const TDesC& aMessage )

	{

	if( aCallback && ( KLiwOptASyncronous & aCmdOptions ) )

		{

		AppendErrorMessageL( aCmdName, KNullDesC8, aMessage, 2/*For KErrArgument*/ );

		}

	}

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

// Two-phased constructor.

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

//

CMessagingInterface* CMessagingInterface::NewL()

	{

  	CMessagingInterface* self = new (ELeave) CMessagingInterface();

  	CleanupStack::PushL( self );

  	self->ConstructL();

  	CleanupStack::Pop( self );

	return self;

	}

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

// Destructor.

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

//	

CMessagingInterface::~CMessagingInterface()

	{

	delete iErrorMessage;

	delete iMsgService;

	}

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

// Closes the interface

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

//

void CMessagingInterface::Close()

	{

	delete this;

	}

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

// Constructor

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

//

CMessagingInterface::CMessagingInterface(): iErrorMessage(0)

	{

	}

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

// Symbian Constructor

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

//	

void CMessagingInterface::ConstructL()

	{

	iMsgService = CMessagingService::NewL();	

	}

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

//  Executes the SAPI as per params

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

//

void CMessagingInterface::ExecuteCmdL( const TDesC8& aCmdName,

					                       const CLiwGenericParamList& aInParamList,

					                       CLiwGenericParamList& aOutParamList,

					                       TUint aCmdOptions,

					                       MLiwNotifyCallback* aCallback )

	{

	TInt errcode = KErrNotSupported;

	TInt32 transactionId(-1);

	if( ( aCallback && !( KLiwOptASyncronous & aCmdOptions ) ) 

	 || ( !aCallback && ( KLiwOptASyncronous & aCmdOptions ) ) )

		{//if any one of them is set it is an error

		errcode = KErrArgument;		

		AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidCallbackSetup, 0 );

		}

	if ( aCmdName.CompareF( KCmdGetHeaderList ) == 0 )

		{

		TRAP( errcode, GetHeaderListL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}

	else if ( aCmdName.CompareF( KCmdSendMessage ) == 0 )

		{

		TRAP( errcode, SendMessageL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}	

	else if ( aCmdName.CompareF( KCmdRegNotification ) == 0 )

		{

		TRAP( errcode, RequestNotificationL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}

	else if ( aCmdName.CompareF( KCmdCancelNotification ) == 0 )

		{

		TRAP( errcode, CancelNotificationL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}		

	else if ( aCmdName.CompareF( KCmdDeleteMsg ) == 0 )

		{

		TRAP( errcode, DeleteMessageL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}		

	else if ( aCmdName.CompareF( KCmdChangeStatus ) == 0 )

		{

		TRAP( errcode, ChangeStatusL( aInParamList, aOutParamList, aCmdOptions, aCallback ) );

		}		

	else if ( aCmdName.CompareF( KCmdCancel ) == 0 )

		{		

		TRAP( errcode, CancelAsyncL( aCmdName, aInParamList, aOutParamList, aCmdOptions) );

		}			

	else 

		{			

		AppendErrorMessageL( aCmdName, KNullDesC8, KInvalidCMD, 0 );		

		}

	aOutParamList.AppendL(TLiwGenericParam( KErrorCode, 

							  TLiwVariant(ErrCodeConversion(errcode))));

	if( errcode != KErrNone )

		{

		aOutParamList.Reset();

		aOutParamList.AppendL(TLiwGenericParam( KErrorCode, 

							  TLiwVariant(ErrCodeConversion(errcode))));		

		if ( iErrorMessage )

			{

			aOutParamList.AppendL(TLiwGenericParam( KErrorMessage, 

								  TLiwVariant(iErrorMessage->Des())));

			delete iErrorMessage;

			iErrorMessage = NULL;		

			}

		}		

	}

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

// Issues SendMessage request to MessagingService

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

//	

void CMessagingInterface::SendMessageL( const CLiwGenericParamList& aInParamList,

					                       CLiwGenericParamList& aOutParamList,

					                       TUint aCmdOptions,

					                       MLiwNotifyCallback* aCallback )

	{

	CSendMessageParams* sendParam = GetSendParametersL( aInParamList );

	CleanupStack::PushL(sendParam);

	CMsgCallbackBase* callback = NULL;

	if ( aCallback && ( KLiwOptASyncronous & aCmdOptions ))

		{

		callback = CMsgCallbackInt::NewL();

		CleanupStack::PushL( callback );

		callback->iPtrInParamList = &aInParamList;

		callback->iPtrNotifyCallback = aCallback;

		callback->iTransactionId = aCallback->GetTransactionID();

		aOutParamList.AppendL(TLiwGenericParam( KTransactionID, 

								TLiwVariant( callback->iTransactionId )));		

		}

	// callback ownership Passed to SendMessageL

	iMsgService->SendMessageL( sendParam, callback );

	if ( callback )

		CleanupStack::Pop( callback );

	CleanupStack::PopAndDestroy( sendParam );

	}

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

// Cancel an Asynch request

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

//

void CMessagingInterface::CancelAsyncL( const TDesC8& aCmdName,

										const CLiwGenericParamList& aInParamList,

				                       	CLiwGenericParamList& aOutParamList,

				                       	TUint aCmdOptions)

	{

	TInt errcode = KErrNotSupported;

	TInt32 transactionId(-1);

    if( KLiwOptCancel & aCmdOptions )

		{

		GetTransactionIdL( aInParamList, transactionId, KCmdCancel);

		errcode = iMsgService->Cancel( transactionId );				

		if ( errcode == KErrNotFound )

			{

			AppendErrorMessageL( aCmdName, KTransactionID, KIncorrectValue, 2 );

			}

		}

	else

		{				

		AppendErrorMessageL( aCmdName, KNullDesC8, KErrMsgMissingLiwCancel, 2 );

		}		

	}

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

// Issues GetList request to MessagingService

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

//	

void CMessagingInterface::GetHeaderListL( const CLiwGenericParamList& aInParamList,

					                       CLiwGenericParamList& aOutParamList,

					                       TUint aCmdOptions,

					                       MLiwNotifyCallback* aCallback )

	{

	LeaveIfAsynchronousL( aCmdOptions, aCallback, KCmdGetHeaderList, KAsyncNotSupported );

	const TLiwGenericParam* param = NULL;

	TBool indexBaseInp = EFalse;

	TInt pos = 0;

	TMsvId folderId = KMsvGlobalInBoxIndexEntryId;//default is inbox

	param = aInParamList.FindFirst( pos, KContentType );

	if( !param )

		{

		if( aInParamList.Count() ) //changed from 1 to non zero

			{

			param = &aInParamList[0];//changed from 1 to 0 

			if( param->Name().Compare( KNullDesC8 ) )

				{

				AppendErrorMessageL( KCmdGetHeaderList, KContentType, KMissing, 1 );	

				}

			indexBaseInp = ETrue; //Indexed based parsing not name value based	

			}

		}

	if ( param && CheckInputTypeL( &param->Value(), ETrue, LIW::EVariantTypeDesC, KCmdGetHeaderList, KContentType, KTypeInvalid ) )

		{ 

		TPtrC value = param->Value().AsDes();

		if ( value.CompareF( KInbox ) == 0 )

			{

			folderId = KMsvGlobalInBoxIndexEntryId;

			}

		else

			{

			AppendErrorMessageL( KCmdGetHeaderList, KContentType, KIncorrectValue, 2 );

			}

		}

	else

		{

		AppendErrorMessageL( KCmdGetHeaderList, KContentType, KMissing, 1 );

		}

	CFilterParamInfo* filterParam = GetFilterParametersL( aInParamList, indexBaseInp );

	CleanupStack::PushL( filterParam );

	CMsvEntrySelection* entrySelection = NULL;

	iMsgService->GetIdListL( filterParam, 

									folderId, 

									NULL/*Callback*/, 

									entrySelection );

	CleanupStack::Pop( filterParam );

	// Successfull completion

	// filterParam and entrySelection ownership passed to called function

	UpdateOutputAsIdListL( &aOutParamList, entrySelection, iMsgService, filterParam );

	}

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

// Issues request for new message notifications to MessagingService

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

//	

void CMessagingInterface::RequestNotificationL( const CLiwGenericParamList& aInParamList,

					                       CLiwGenericParamList& aOutParamList,

					                       TUint aCmdOptions,

					                       MLiwNotifyCallback* aCallback )

	{

	if ( ! (aCallback && ( KLiwOptASyncronous & aCmdOptions ) ) ) 

		{

		AppendErrorMessageL( KCmdRegNotification, KNullDesC8, KSyncNotSupported, 2 );

		}

	TNotificationType notificationType;

	GetNotificationTypeL( aInParamList, notificationType, KCmdRegNotification );

	CMsgCallbackBase* callback = NULL;

	callback = CMsgCallbackHeader::NewL();

	callback->iPtrInParamList = &aInParamList;

	callback->iPtrNotifyCallback = aCallback;

	callback->iTransactionId = aCallback->GetTransactionID();

	TInt errcode = iMsgService->RequestNotification( notificationType, callback );

	if ( errcode != KErrNone )

		{