// 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:

//

#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 "EMSObjectDistributionIE.h"

#include <fbs.h>

EXPORT_C TBool EmsTestUtils::CompareEmsIE(const CEmsInformationElement& aLeft, const CEmsInformationElement& aRight)

	{

	TBool retVal = EFalse;

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

	if ((aLeft.Identifier() == aRight.Identifier()) &&

		(aLeft.StartPosition() == aRight.StartPosition()) &&

		(aLeft.Length() == aRight.Length()))

		{

		switch(aLeft.Identifier())

			{

			case CSmsInformationElement::ESmsEnhancedTextFormatting:

				{

				const CEmsFormatIE& leftIE = static_cast<const CEmsFormatIE&>(aLeft);

				const CEmsFormatIE& rightIE = static_cast<const CEmsFormatIE&>(aRight);

				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&>(aLeft);

				const CEmsPreDefSoundIE& rightIE = static_cast<const CEmsPreDefSoundIE&>(aRight);

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

				break;

				}

			case CSmsInformationElement::ESmsEnhancedUserDefinedSound:

				{

				const CEmsSoundIE& leftIE = static_cast<const CEmsSoundIE&>(aLeft);

				const CEmsSoundIE& rightIE = static_cast<const CEmsSoundIE&>(aRight);

				// 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&>(aLeft);

				const CEmsPreDefAnimationIE& rightIE = static_cast<const CEmsPreDefAnimationIE&>(aRight);

				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&>(aLeft);

				const CEmsPictureIE& rightIE = static_cast<const CEmsPictureIE&>(aRight);

				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&>(aLeft);

				const CEmsUserPrompt& rightIE = static_cast<const CEmsUserPrompt&>(aRight);

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

				break;

				}

			case CSmsInformationElement::ESmsEnhancedODI:

				{

				const CEmsObjectDistribution& leftIE = static_cast<const CEmsObjectDistribution&>(aLeft);

				const CEmsObjectDistribution& rightIE = static_cast<const CEmsObjectDistribution&>(aRight);

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

				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;

			}

		}

    // if an ODI, start position doesn't have to match

    else if (aLeft.Identifier() == CSmsInformationElement::ESmsEnhancedODI)

        {

        const CEmsObjectDistribution& leftIE = static_cast<const CEmsObjectDistribution&>(aLeft);

		const CEmsObjectDistribution& rightIE = static_cast<const CEmsObjectDistribution&>(aRight);

        retVal = (leftIE.ObjectCount() == rightIE.ObjectCount()) && (leftIE.Forwarding() == rightIE.Forwarding()) &&

                  (leftIE.Identifier() == rightIE.Identifier()) && (leftIE.Length() == rightIE.Length());

        }

	return retVal;

	}

EXPORT_C TBool EmsTestUtils::CompareEmsMsgL(const CSmsMessage& aLeft, const CSmsMessage& aRight)

	{

	TBool retVal = ETrue;

	RSafeEmsArray leftAdjusted, rightAdjusted;

	CleanupClosePushL(leftAdjusted);

	CleanupClosePushL(rightAdjusted);

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

	// segmented formatting objects

	AdjustedEmsObjectsL(aLeft, leftAdjusted);

	AdjustedEmsObjectsL(aRight, 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 (TInt i = 0; i < leftAdjusted.Count(); ++i)

			{

			TInt 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 EFalse

			if (j == rightAdjusted.Count())

				{

				retVal = EFalse;

				break;

				}

			}

		}

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

	if (retVal)

		{

		HBufC* leftText = ExtractSmsTextLC(aLeft);

		HBufC* rightText = ExtractSmsTextLC(aRight);

		// 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& aMsg, CSmsInformationElement::TSmsInformationElementIdentifier aId)

	{

	const RPointerArray<const CEmsInformationElement>& arr =

		aMsg.GetEMSInformationElementsL();

	TInt cnt = arr.Count();

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

		{

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

			return arr[i];

		}

	return NULL;

	}

EXPORT_C CEmsPictureIE* EmsTestUtils::CreatePictureL(TInt aIndex)

	{

	// path of the pictures

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

	// Create the picture object

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

	return picture;

	}

EXPORT_C CEmsAnimationIE* EmsTestUtils::CreateAnimationL(TInt aIndex)

	{

	// path of the animations

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

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

	return anim;

	}

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

	{

	const CSmsBufferBase& buffer = aMsg.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& aMsg, RPointerArray<CEmsInformationElement>& aAdjusted)

	{

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

	// but consolidated

	RPointerArray<CEmsInformationElement> formatObjects(10);

	const RPointerArray<const CEmsInformationElement>& emsObjects =

		aMsg.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)

			{

			aAdjusted.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)

		{

		aAdjusted.Append(formatObjects[i]);

		}

	// make sure array memory has been deallocated

	formatObjects.Close();

	}

template <class T>

T* EmsTestUtils::CreateEmsObjFromBitmapL(const TDesC& aFilename, TInt32 aIndex)

	{

	_LIT(KTxtCDrive,"C:");

	_LIT(KTxtZDrive,"Z:");

	// startup bitmap server

	FbsStartup();

	User::LeaveIfError(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(aFilename, &KTxtCDrive, NULL);

	// did it fail?

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

		{

		// then try drive Z

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

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

		}

 	// if it succeeded, then create the appropriate type

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

	CleanupStack::PopAndDestroy(bmp);

	RFbsSession::Disconnect();

	return obj;

	}