// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "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:
// __ACTION_INFO_BEGIN__
// [Action Name]
// CompareSmsMessages
// [Action Parameters]
// TMsvId		FolderId1   <input>             : Value of Folder Id to be compared with.
// TMsvId		FolderId2   <input>             : Value of Folder Id to be compared
// CMsvSession  session     <input>             : Reference to the session.
// TInt         Result      <output-initiation> : Value of enumerated constants if not
// identical(zero if one folder has
// corresponding same message in other folder).
// [Action Description]
// Compare and check the whether the messages in one folder has corresponding same message
// in other folder. The output of the Test action should be zero if all parts of
// the message in both folders are identical, otherwise the corresponding
// enumerated value of the non-identical part of the message.
// [APIs Used]
// CMsvEntrySelection::ChildrenL
// CMsvEntrySelection::Count
// CMsvSession::GetEntryL
// CMsvEntry::Entry
// CMsvStore::RestoreBodyTextL
// CSmsHeader::RestoreL
// __ACTION_INFO_END__
// 
//

/**
 @file
*/

// system includes
#include <smut.h>
#include <msvapi.h>
#include <txtrich.h>
#include <smuthdr.h>


// user includes
#include "CmtfTestActionCompareSmsMessages.h"
#include "CMtfTestCase.h"
#include "CMtfTestActionParameters.h"

CMtfTestAction* CMtfTestActionCompareSmsMessages::NewL(CMtfTestCase& aTestCase,CMtfTestActionParameters* aActionParameters)
	{
	CMtfTestActionCompareSmsMessages* self = new (ELeave) CMtfTestActionCompareSmsMessages(aTestCase);
	CleanupStack::PushL(self);
	self->ConstructL(aActionParameters);
	CleanupStack::Pop();
	return self;
	}


CMtfTestActionCompareSmsMessages::CMtfTestActionCompareSmsMessages(CMtfTestCase& aTestCase)
	:CMtfSynchronousTestAction(aTestCase)
	{
	}


CMtfTestActionCompareSmsMessages::~CMtfTestActionCompareSmsMessages()
	{
	}

void CMtfTestActionCompareSmsMessages::ExecuteActionL()
	{
	TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCompareSmsMessages);
	TMsvId       paramFolderId1 = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(0));
	TMsvId       paramFolderId2 = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));

	iParamSession   = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(2));

	CMsvEntry* folderEntry1 = CMsvEntry::NewL(*iParamSession,paramFolderId1,TMsvSelectionOrdering());
	CleanupStack::PushL(folderEntry1);
	CMsvEntrySelection* folder1Selection =folderEntry1->ChildrenWithMtmL(KUidMsgTypeSMS);
	CleanupStack::PushL(folder1Selection);
	folderEntry1->SetEntryL(paramFolderId2);
	CMsvEntrySelection* folder2Selection =folderEntry1->ChildrenWithMtmL(KUidMsgTypeSMS);
    CleanupStack::PushL(folder2Selection);
 	TInt count1 = folder1Selection->Count();
	TInt resCount=0;
	TInt enumVal;
	TInt folder1Count=count1;
	TInt count2 = folder2Selection->Count();
	if((count1 <= 0)||(count2 < count1))
		{
		User::Leave(KErrGeneral);
		}
	TMsvId msgId1 = KMsvRootIndexEntryId;
	CMsvEntry* f1Entry = iParamSession->GetEntryL(KMsvRootIndexEntryId);
	CleanupStack::PushL(f1Entry);
	TMsvId msgId2 = KMsvRootIndexEntryId;
	CMsvEntry* f2Entry = iParamSession->GetEntryL(KMsvRootIndexEntryId);
	CleanupStack::PushL(f2Entry);

	while (count1--)
		{
		msgId1 = (*folder1Selection)[count1];
		f1Entry->SetEntryL(msgId1);
		TMsvEntry msgEntry1 = f1Entry->Entry();
		while (count2--)
			{
			msgId2 = (*folder2Selection)[count2];
			f2Entry->SetEntryL(msgId2);
			TMsvEntry msgEntry2 = f2Entry->Entry();

			if (IsMatchHeaderL(*f1Entry, *f2Entry))
				{
				enumVal = EFailedToMatchHeader;
				}
			else if (!IsMatchL(*f1Entry, *f2Entry))
				{
				enumVal = EFailedToMatchBody;
				}
			else
				{
				resCount++;
				if(resCount == folder1Count)
					{
					enumVal = EAllMatched;
					}
				break;
				}
			}
		}
	StoreParameterL<TInt>(TestCase(),enumVal,ActionParameters().Parameter(3));
	CleanupStack::PopAndDestroy(f2Entry);
	CleanupStack::PopAndDestroy(f1Entry);
	CleanupStack::PopAndDestroy(folder2Selection);
	CleanupStack::PopAndDestroy(folder1Selection);
	CleanupStack::PopAndDestroy(folderEntry1);
	TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCompareSmsMessages);
	TestCase().ActionCompletedL(*this);
	}



  TBool CMtfTestActionCompareSmsMessages::IsMatchL(CMsvEntry& aFolder1Msg, CMsvEntry& aFolder2Msg)
/**
 * Compares the body text of Folder1 and Folder2
 *
 * @return Returns ETrue if the body text matches
 */
  {
	HBufC* folder1MsgBody = GetBodyTextL(aFolder1Msg);
	HBufC* folder2MsgBody = GetBodyTextL(aFolder2Msg);
	TBool retVal = (*folder1MsgBody == *folder2MsgBody);
	return retVal;
	}

  TBool CMtfTestActionCompareSmsMessages::IsMatchHeaderL(CMsvEntry& aFolder1Msg, CMsvEntry& aFolder2Msg)
/**
 * Compares the Message Header of  Folder1 and Folder2
 *
 * @return Returns ETrue if the body text matches
 */
  {
	CSmsHeader* folder1MsgHeader = GetSubmitHeaderL(aFolder1Msg);
	CleanupStack::PushL(folder1MsgHeader);
	CSmsHeader* folder2MsgHeader = GetDeliverHeaderL(aFolder2Msg);
	CleanupStack::PushL(folder2MsgHeader);
	
	CArrayPtrFlat<CSmsNumber>& f1Recipients = folder1MsgHeader->Recipients();
	CArrayPtrFlat<CSmsNumber>& f2Recipients = folder2MsgHeader->Recipients();

	TInt f1Count = f1Recipients.Count();
	TInt f2Count = f2Recipients.Count();
    TBool retVal = ETrue;
	if((f1Count == f2Count)&&(folder1MsgHeader->Type()==folder2MsgHeader->Type()))
		{
        for(TInt i=0;i<f1Count;i++)
			{
			retVal = (f1Recipients[i] == f2Recipients[i]);
			if((retVal==EFalse))
			break;
			}
		}
	else
		{
		retVal = EFalse;
		}
	CleanupStack::PopAndDestroy(folder2MsgHeader);
	CleanupStack::PopAndDestroy(folder1MsgHeader);
	return retVal;
	}

  CSmsHeader* CMtfTestActionCompareSmsMessages::GetSubmitHeaderL(CMsvEntry& aMessage)
/**
 * Returns the CSmsHeader restored from message aMessage.
 */
	{
	CSmsHeader* header = CSmsHeader::NewL(CSmsMessage::NewL(iParamSession->FileSession(), CSmsPDU::ESmsSubmit, CSmsBuffer::NewL()));
	CleanupStack::PushL(header);

	CMsvStore* store = aMessage.ReadStoreL();
	CleanupStack::PushL(store);
	header->RestoreL(*store);
	CleanupStack::PopAndDestroy(store);

	CleanupStack::Pop(header);
	return header;
	}

  CSmsHeader* CMtfTestActionCompareSmsMessages::GetDeliverHeaderL(CMsvEntry& aMessage)
  /**
   * Returns the CSmsHeader restored from message aMessage.
   */
  	{
  	CSmsHeader* header = CSmsHeader::NewL(CSmsMessage::NewL(iParamSession->FileSession(), CSmsPDU::ESmsDeliver, CSmsBuffer::NewL()));
  	CleanupStack::PushL(header);

 	CMsvStore* store = aMessage.ReadStoreL();
  	CleanupStack::PushL(store);
  	header->RestoreL(*store);
  	CleanupStack::PopAndDestroy(store);

	CleanupStack::Pop(header);
  	return header;
  	}


HBufC* CMtfTestActionCompareSmsMessages::GetBodyTextL(CMsvEntry& aMessage)
/**
 * @return The body text of message aMessage
 */
	{
	CMsvStore* store = aMessage.ReadStoreL();
	CleanupStack::PushL(store);

	CRichText* richText;
	CParaFormatLayer* paraFormatLayer;
    CCharFormatLayer* charFormatLayer;
    paraFormatLayer=CParaFormatLayer::NewL();
	CleanupStack::PushL(paraFormatLayer);
    charFormatLayer=CCharFormatLayer::NewL();
	CleanupStack::PushL(charFormatLayer);

    richText=CRichText::NewL(paraFormatLayer, charFormatLayer);
	CleanupStack::PushL(richText);
	store->RestoreBodyTextL(*richText);
	const TInt len =richText->DocumentLength();
	HBufC* buf = HBufC::NewL(len);
	TPtr ptr(buf->Des());
	richText->Extract(ptr);
	CleanupStack::PopAndDestroy(richText);
	CleanupStack::PopAndDestroy(charFormatLayer);
	CleanupStack::PopAndDestroy(paraFormatLayer);
	CleanupStack::PopAndDestroy(store);
	return buf;
	}