// 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 "thelpers.h"

// System includes
#include <e32math.h>
#include <charconv.h>
#include <concnf.h>
#include <confndr.h>
#include <conlist.h>
#include <utf.h>
#include <vprop.h>

// Constants
//_LIT8(KReplacementChars, " ?");


//
// VTestHelpers (source)
//


//****************************************************************************************
TInt VTestHelpers::MakeRandomNumber(const TInt aLow, const TInt aHigh, TInt64& aSeed)
	{
	TReal initialRand = (Math::FRand(aSeed) * (aHigh - aLow));
	TInt32 rand;

	// Round to 0 decimal places, ie. the nearest whole numer
	Math::Round(initialRand, initialRand, 0);
	Math::Int(rand, initialRand);

	return (aLow + rand);
	}


//****************************************************************************************
/*void VTestHelpers::ConvertUnicodeToNarrowL(const TDesC16& aSource, TDes8& aDest, TUint aCharConvCharSet)
	{
	TInt stateValueDummyParameter = 0;

	switch(aCharConvCharSet)
		{
		// UTF-X
		case KVersitTest2InternalUidForUTF8:
		{
			User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(aDest, aSource));
			break;
		}
		case KVersitTest2InternalUidForUTF7:
		{
			User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf7(aDest, aSource, stateValueDummyParameter));
			break;
		}
		
		// ISO-X
		case KCharacterSetIdentifierIso88591:
		case KCharacterSetIdentifierIso88592:
		case KCharacterSetIdentifierIso88594:
		case KCharacterSetIdentifierIso88595:
		case KCharacterSetIdentifierIso88597:
		case KCharacterSetIdentifierIso88599:
		{
			RFs fileServerSession;
			CleanupClosePushL(fileServerSession);
			User::LeaveIfError(fileServerSession.Connect());
			CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC();

			CCnvCharacterSetConverter::TAvailability avail=CCnvCharacterSetConverter::ENotAvailable;
			avail = characterSetConverter->PrepareToConvertToOrFromL(aCharConvCharSet, fileServerSession);
			if (avail==CCnvCharacterSetConverter::ENotAvailable)
				{
				CleanupStack::PopAndDestroy(2);
				return;
				}

			characterSetConverter->SetReplacementForUnconvertibleUnicodeCharactersL(KReplacementChars);
			characterSetConverter->ConvertFromUnicode(aDest, aSource);	

			CleanupStack::PopAndDestroy(2); // fileserver, charactersetconverter

			TBuf8<1000> buffer1 = aDest;
			TInt pos = 0;
			const TInt length = aDest.Length();
			for(TInt i=1; i<length; i+=2)
				{
				buffer1[pos] = buffer1[i];
				pos++;
				}
			aDest = buffer1;
			aDest.SetLength(length/2);
			break;
		}

		// Not handled by CharConv
		default:
		{
			const TInt length = aSource.Length();
			aDest.SetLength(length);
			for(TInt i = 0; i < length; i++)
				aDest[i] = (TUint8) aSource[i];
			break;
		}
		}

	}*/


//****************************************************************************************
TBool VTestHelpers::DoesParameterAlreadyExist(CArrayPtr<CParserParam>* aArrayOfParams, const TDesC8& aName)
	{
	for(TInt i=0; i<aArrayOfParams->Count(); i++)
		{
		if	(aArrayOfParams->At(i)->Name() == aName)
			return ETrue;
		}

	return EFalse;
	}


//
//
//


//****************************************************************************************
CParserPropertyValueHBufC* VTestHelpers::CreateTextPropertyValueL(const TDesC& aValue)
	{
	CParserPropertyValueHBufC* value = CParserPropertyValueHBufC::NewL(aValue);
	return value;
	}


//****************************************************************************************
CParserPropertyValueDateTime* VTestHelpers::CreateDateTimePropertyValueL(const TDateTime& aDateTime)
	{
	TVersitDateTime* versitDateTime = new(ELeave) TVersitDateTime(aDateTime, TVersitDateTime::EIsMachineLocal);
	CleanupStack::PushL(versitDateTime);
	CParserPropertyValueDateTime* value = new(ELeave) CParserPropertyValueDateTime(versitDateTime); // takes ownership
	CleanupStack::Pop(versitDateTime);
	return value;
	}


//****************************************************************************************
CParserPropertyValueDate* VTestHelpers::CreateDatePropertyValueL(const TDateTime& aDateTime)
	{
	TVersitDateTime* versitDateTime = new(ELeave) TVersitDateTime(aDateTime, TVersitDateTime::EIsMachineLocal);
	CleanupStack::PushL(versitDateTime);
	CParserPropertyValueDate* value = new(ELeave) CParserPropertyValueDate(versitDateTime); // takes ownership
	CleanupStack::Pop(versitDateTime);
	return value;
	}


//
//
//


//****************************************************************************************
void VTestHelpers::CreateDescriptorArrayL(const TDesC& aItem, CDesCArray*& aArray, TBool aAddSpace)
	{
	CleanupStack::PushL(aArray);
	if (!aAddSpace)
		aArray->AppendL(aItem);
	else
		{
		TBuf<64> string;
		string.Append(' ');
		string.Append(aItem);
		aArray->AppendL(string);
		}
	CleanupStack::Pop();
	}


//****************************************************************************************
CParserPropertyValueCDesCArray* VTestHelpers::CreateArrayPropertyValueL(CDesCArray* aArray)
	{
	CleanupStack::PushL(aArray);
	CParserPropertyValueCDesCArray* value = new(ELeave) CParserPropertyValueCDesCArray(aArray);
	CleanupStack::Pop();
	return value;
	}








//
// CComparitorParserProperty (source)
//


//****************************************************************************************
TBool CComparitorParserProperty::IsEqualL(const CComparitorParserProperty* aProp) const
	{
	if	(aProp->Name() != Name())
		return EFalse;
	if	(aProp->Value()->Uid() != Value()->Uid())
		return EFalse;
	if	(aProp->ParameterCount() != ParameterCount())
		return EFalse;


	switch(aProp->Value()->Uid().iUid)
		{
	case KVersitPropertyCDesCArrayUid:
		{
		return PropCDesCArrayIsEqualL(STATIC_CAST(const CParserPropertyValueCDesCArray*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueCDesCArray*, Value())->Value());
		}
	case KVersitPropertyTimeZoneUid:
		{
		return PropTimeZoneIsEqualL(STATIC_CAST(const CParserPropertyValueTimeZone*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueTimeZone*, Value())->Value());
		}
	case KVersitPropertyDaylightUid:
		{
		return PropDaylightIsEqualL(STATIC_CAST(const CParserPropertyValueDaylight*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueDaylight*, Value())->Value());
		}
	case KVersitPropertyDateTimeUid:
		{
		return PropDateTimeIsEqualL(STATIC_CAST(const CParserPropertyValueDateTime*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueDateTime*, Value())->Value());
		}
	case KVersitPropertyDateUid:
		{
		return PropDateIsEqualL(STATIC_CAST(const CParserPropertyValueDate*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueDate*, Value())->Value());
		}
	case KVersitPropertyMultiDateTimeUid:
		{
		return PropMultiDateTimeIsEqualL(STATIC_CAST(const CParserPropertyValueMultiDateTime*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueMultiDateTime*, Value())->Value());
		}
	case KVersitPropertyIntUid:
		{
		return PropIntIsEqualL(STATIC_CAST(const CParserPropertyValueInt*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueInt*, Value())->Value());
		}
	default:
		{
		return PropHBufCIsEqualL(STATIC_CAST(const CParserPropertyValueHBufC*, aProp->Value())->Value(), STATIC_CAST(CParserPropertyValueHBufC*, Value())->Value());
		}
		}
	}


//
//
//


//****************************************************************************************
TBool CComparitorParserProperty::PropCDesCArrayIsEqualL(CDesCArray* a1, CDesCArray* a2)
	{
	TInt count = a1->MdcaCount();
	if	(count != a2->MdcaCount())
		return EFalse;

	for(TInt i=0; i<count; i++)
		{
		const TDesC& des = a1->MdcaPoint(i);
		if	(des.CompareC(a2->MdcaPoint(i)))
			return EFalse;
		}
	return ETrue;
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropTimeZoneIsEqualL(TTimeIntervalSeconds a1, TTimeIntervalSeconds a2)
	{
	return (a1.Int() == a2.Int());
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropDaylightIsEqualL(CVersitDaylight* a1, CVersitDaylight* a2)
	{
	if	(a1->iSavings != a2->iSavings)
		return EFalse;
	if	(a1->iOffset.Int() != a2->iOffset.Int())
		return EFalse;

	// Just compare the dateTime not the relative time
	if	(!DateTimeIsEqual(a1->iStartTime->iDateTime, a2->iStartTime->iDateTime))
		return EFalse;
	if	(!DateTimeIsEqual(a1->iEndTime->iDateTime, a2->iEndTime->iDateTime))
		return EFalse;

	if	(a1->iStandardDesignation->CompareC(*a2->iStandardDesignation))
		return EFalse;
	if	(a1->iDaylightDesignation->CompareC(*a2->iDaylightDesignation))
		return EFalse;
	return ETrue;
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropDateTimeIsEqualL(TVersitDateTime* a1, TVersitDateTime* a2)
	{
	return DateTimeIsEqual(a1->iDateTime, a2->iDateTime);
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropDateIsEqualL(TVersitDateTime* a1, TVersitDateTime* a2)
	{
	return DateEqual(a1->iDateTime, a2->iDateTime);
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropMultiDateTimeIsEqualL(CArrayPtr<TVersitDateTime>* a1, CArrayPtr<TVersitDateTime>* a2)
	{
	if	((!a1 && a2) || (a1 && !a2))
		return EFalse;

	TInt count = a1->Count();
	if	(count != a2->Count())
		return EFalse;

	for(TInt i=0; i<count; i++)
		{
		if	(!PropDateTimeIsEqualL(a1->At(i), a2->At(i)))
			return EFalse;
		}
	return ETrue;
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropIntIsEqualL(TInt a1, TInt a2)
	{
	return (a1 == a2);
	}


//****************************************************************************************
TBool CComparitorParserProperty::PropHBufCIsEqualL(const TDesC& a1, const TDesC& a2)
	{
	return !(a1.CompareC(a2));
	}


//****************************************************************************************
TBool CComparitorParserProperty::DateTimeIsEqual(const TDateTime& a1, const TDateTime& a2)
	{
	TTime time1(a1);
	TTime time2(a2);
	return (time1 == time2);
	}


//****************************************************************************************
TBool CComparitorParserProperty::DateEqual(const TDateTime& a1, const TDateTime& a2)
	{
	if	(a1.Year() == a2.Year() && a1.Month() == a2.Month() && a1.Day() == a2.Day())
		return ETrue;
	return EFalse;
	}



//
// CParserPropertyWithoutCharsetTags (source)
//

//****************************************************************************************
void CParserPropertyWithoutCharsetTags::RemoveAllCharsetTagsFromParametersL()
	{
	if	(!iArrayOfParams)
		return;

	TInt count = iArrayOfParams->Count();
	for(TInt i=count-1; i>=0; i--)
		{
		CParserParam* param = iArrayOfParams->At(i);
		HBufC8* name = param->Name().AllocLC();
		TPtr8 pName = name->Des();
		pName.UpperCase();
		pName.Trim();

		if	(pName == KVersitTokenCHARSET)
			{
			iArrayOfParams->Delete(i);
			delete param;
			}
		CleanupStack::PopAndDestroy(); // name
		}
	}