// Copyright (c) 1999-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:

//

#include "emstestutils.h"

#include <emsinformationelement.h>

#include <gsmumsg.h>

#include <gsmubuf.h>

#include <emsformatie.h>

#include <emssoundie.h>

#include <emsanimationie.h>

#include <emspictureie.h>

#include <emsuserpromptie.h>

#include <fbs.h>

EXPORT_C TBool EmsTestUtils::CompareEmsIE(const CEmsInformationElement& left, const CEmsInformationElement& right)

	{

	TBool retVal = EFalse;

	// make sure the types, start position, and length are the same

	if ((left.Identifier() == right.Identifier()) &&

		(left.StartPosition() == right.StartPosition()) &&

		(left.Length() == right.Length()))

		{

		switch(left.Identifier())

			{

			case CSmsInformationElement::ESmsEnhancedTextFormatting:

				{

				const CEmsFormatIE& leftIE = STATIC_CAST(const CEmsFormatIE&, left);

				const CEmsFormatIE& rightIE = STATIC_CAST(const CEmsFormatIE&, right);

				retVal = (leftIE.FormatLength() == rightIE.FormatLength())   &&

						 (leftIE.Bold() == rightIE.Bold())                   &&

						 (leftIE.Italic() == rightIE.Italic())               &&

						 (leftIE.Underline() == rightIE.Underline())         &&

						 (leftIE.Strikethrough() == rightIE.Strikethrough()) &&

						 (leftIE.Alignment() == rightIE.Alignment())         &&

						 (leftIE.FontSize() == rightIE.FontSize());

				break;

				}

			case CSmsInformationElement::ESmsEnhancedPredefinedSound:

				{

				const CEmsPreDefSoundIE& leftIE = STATIC_CAST(const CEmsPreDefSoundIE&, left);

				const CEmsPreDefSoundIE& rightIE = STATIC_CAST(const CEmsPreDefSoundIE&, right);

				retVal = (leftIE.PredefinedSound() == rightIE.PredefinedSound());

				break;

				}

			case CSmsInformationElement::ESmsEnhancedUserDefinedSound:

				{

				const CEmsSoundIE& leftIE = STATIC_CAST(const CEmsSoundIE&, left);

				const CEmsSoundIE& rightIE = STATIC_CAST(const CEmsSoundIE&, right);

				// returns TRUE if the melodies are identical - ie if the

				// compare returns 0 and hence the NOT operator

				retVal = !(leftIE.Melody()->Compare(*rightIE.Melody()));

				break;

				}

			case CSmsInformationElement::ESmsEnhancedPredefinedAnimation:

				{

				const CEmsPreDefAnimationIE& leftIE = STATIC_CAST(const CEmsPreDefAnimationIE&, left);

				const CEmsPreDefAnimationIE& rightIE = STATIC_CAST(const CEmsPreDefAnimationIE&, right);

				retVal = (leftIE.Animation() == rightIE.Animation());

				break;

				}

			case CSmsInformationElement::ESmsEnhancedLargePicture:

			case CSmsInformationElement::ESmsEnhancedSmallPicture:

			case CSmsInformationElement::ESmsEnhancedVariablePicture:

				{

				// for pictures, we can only compare the size, not the actual

				// content

				const CEmsPictureIE& leftIE = STATIC_CAST(const CEmsPictureIE&, left);

				const CEmsPictureIE& rightIE = STATIC_CAST(const CEmsPictureIE&, right);

				retVal = (leftIE.SizeInPixels() == rightIE.SizeInPixels());

				break;

				}

			case CSmsInformationElement::ESmsEnhancedUserPromptIndicator:

				{

				// for pictures, we can only compare the size, not the actual

				// content

				const CEmsUserPrompt& leftIE = STATIC_CAST(const CEmsUserPrompt&, left);

				const CEmsUserPrompt& rightIE = STATIC_CAST(const CEmsUserPrompt&, right);

				retVal = (leftIE.ObjectCount() == rightIE.ObjectCount());

				break;

				}

			case CSmsInformationElement::ESmsEnhancedLargeAnimation:

			case CSmsInformationElement::ESmsEnhancedSmallAnimation:

				// for animations, we can't really compare anything

				retVal = ETrue;

				break;

			default:

				// if we come across an unknown ID, we just return false

				retVal = EFalse;

				break;

			}

		}

	return retVal;

	}

EXPORT_C TBool EmsTestUtils::CompareEmsMsgL(const CSmsMessage& left, const CSmsMessage& right)

	{

	TBool retVal = ETrue;

	RSafeEmsArray leftAdjusted, rightAdjusted;

	CleanupClosePushL(leftAdjusted);

	CleanupClosePushL(rightAdjusted);

	// Produce the adjusted ems objects so we can also compare

	// segmented formatting objects

	AdjustedEmsObjectsL(left, leftAdjusted);

	AdjustedEmsObjectsL(right, rightAdjusted);

	// make sure the number of ems objects match

	if (leftAdjusted.Count() != rightAdjusted.Count())

		{

		retVal = EFalse;

		}

	else

		{

		// for each EMS element in left, make sure we can find another

		// element in right which matches completely

		for (int i = 0; i < leftAdjusted.Count(); ++i)

			{

			int j;

			for (j = 0; j < rightAdjusted.Count(); ++j)

				{

				if (CompareEmsIE(*leftAdjusted[i], *rightAdjusted[j]))

					{

					break;

					}

				}

			// if j == right.Count(), this means we went through the entire

			// array without finding a match. Hence we return FALSE

			if (j == rightAdjusted.Count())

				{

				retVal = EFalse;

				break;

				}

			}

		}

	// if EMS objects OK, then compare text as well

	if (retVal)

		{

		HBufC* leftText = ExtractSmsTextLC(left);

		HBufC* rightText = ExtractSmsTextLC(right);

		// do a text compare

		retVal = (TPtr(leftText->Des()) == TPtr(rightText->Des()));

		CleanupStack::PopAndDestroy(rightText);

		CleanupStack::PopAndDestroy(leftText);

		}

	// pop the adjusted arrays

	CleanupStack::PopAndDestroy(&rightAdjusted);

	CleanupStack::PopAndDestroy(&leftAdjusted);

	return retVal;

	}

EXPORT_C const CEmsInformationElement* EmsTestUtils::FindElementL(

		const CSmsMessage& msg, CSmsInformationElement::TSmsInformationElementIdentifier id)

	{

	const RPointerArray<const CEmsInformationElement>& arr = 

		msg.GetEMSInformationElementsL();

	TInt cnt = arr.Count();

	for (TInt i = 0; i < cnt; ++i)

		{

		if (arr[i]->Identifier() == id)

			return arr[i];

		}

	return NULL;

	}

EXPORT_C CEmsPictureIE* EmsTestUtils::CreatePictureL(TInt index)

	{

	// path of the pictures

	_LIT(KPicsMBM,"\\Ems\\pics.mbm");

	// Create the picture object

	CEmsPictureIE* picture = CreateEmsObjFromBitmapL<CEmsPictureIE>(KPicsMBM, index);

	return picture;

	}

EXPORT_C CEmsAnimationIE* EmsTestUtils::CreateAnimationL(TInt index)

	{

	// path of the animations

	_LIT(KAnimsMBM,"\\Ems\\anims.mbm");

	CEmsAnimationIE* anim = CreateEmsObjFromBitmapL<CEmsAnimationIE>(KAnimsMBM, index);

	return anim;

	}

HBufC* EmsTestUtils::ExtractSmsTextLC(const CSmsMessage& msg)

	{

	const CSmsBufferBase& buffer = msg.Buffer();

	TInt bufLen=buffer.Length();

	HBufC* textBuf=HBufC::NewL(bufLen);

	CleanupStack::PushL(textBuf);

	TPtr textPtr(textBuf->Des());

	buffer.Extract(textPtr,0,bufLen);

	return textBuf;

	}

void EmsTestUtils::AdjustedEmsObjectsL(

		const CSmsMessage& msg, RPointerArray<CEmsInformationElement>& adjusted)

	{

	// This will contain all the formatting objects of the message,

	// but consolidated

	RPointerArray<CEmsInformationElement> formatObjects(10);

	const RPointerArray<const CEmsInformationElement>& emsObjects = 

		msg.GetEMSInformationElementsL();

	// now go through the array in the message, and copy the objects

	// if they are not format objects. Format objects go in a separate

	// array for consolidation

	TInt i;	

	for (i = 0; i < emsObjects.Count(); ++i)

		{

		if (emsObjects[i]->Identifier() != CSmsInformationElement::ESmsEnhancedTextFormatting)

			{

			adjusted.Append(emsObjects[i]->DuplicateL());

			}

		else

			{

			// otherwise, go through the format list and see if can be appended

			// to an existing format object

			const CEmsFormatIE* formatIE = STATIC_CAST(const CEmsFormatIE*, emsObjects[i]);

			TInt j;

			for (j = 0; j < formatObjects.Count(); ++j)

				{

				// check if the start position of this element equals the

				// startPos + length of the other format object

				CEmsFormatIE* other = STATIC_CAST(CEmsFormatIE*, formatObjects[j]);

				if (formatIE->StartPosition() == other->StartPosition() + other->FormatLength() &&

					formatIE->Bold() == other->Bold() &&

					formatIE->Italic() == other->Italic() &&

					formatIE->Underline() == other->Underline() &&

					formatIE->Strikethrough() == other->Strikethrough() &&

					formatIE->Alignment() == other->Alignment() &&

					formatIE->FontSize() == other->FontSize())

					{

					// add the length

					other->SetFormatLength(other->FormatLength() + formatIE->FormatLength());

					break;

					}

				}

			// if we have gone to the end without appending to another element,

			// then clone the element and add it to the formatObjects array

			if (j == formatObjects.Count())

				{

				formatObjects.Append(formatIE->DuplicateL());

				}

			}

		}

	// Now, move all elements from the format objects into the adjusted array

	for (i = 0; i < formatObjects.Count(); ++i)

		{

		adjusted.Append(formatObjects[i]);

		}

	// make sure array memory has been deallocated

	formatObjects.Close();

	}

template <class T>	

T* EmsTestUtils::CreateEmsObjFromBitmapL(const TDesC& filename, TInt32 index)

	{

	_LIT(KTxtCDrive,"C:");

	_LIT(KTxtZDrive,"Z:");

	// startup bitmap server

	FbsStartup();

	RFbsSession::Connect();

	// Given a particular filename, assumed to be in C:\ or Z:\, we load

	// a bitmap from the given index. The bitmap is pushed onto the

	// cleanup stack

	CFbsBitmap* bmp;

	TParse mbfn;

	bmp = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(bmp);

	// load the indexed bitmap, first in drive C, then drive Z

	mbfn.Set(filename, &KTxtCDrive, NULL);

	// did it fail? 

	if (bmp->Load(mbfn.FullName(), index))

		{

		// then try drive Z

		mbfn.Set(filename, &KTxtZDrive, NULL);

		User::LeaveIfError(bmp->Load(mbfn.FullName(), index));

		}

 	// if it succeeded, then create the appropriate type

	T* obj = T::NewL(*bmp);

	CleanupStack::PopAndDestroy(bmp);

	RFbsSession::Disconnect();

	return obj;

	}