// Copyright (c) 1997-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 <versit.h>

#include <vprop.h>

#include <vutil.h>

#include <s32mem.h>

#include <concnf.h>

#include <confndr.h>

#include <conlist.h>

#include <charconv.h>

#include <utf.h>

#include <vcal.h>

#include <vcard.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <vpropbinaryfile.h>

#include "versit_internal.h"

#endif 

// User includes

#include <vstaticutils.h>

#include <vobserv.h>

#include "vpbapplugin.h"

// Constants

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

const TInt KRandomnumberlen = 5;

const TInt KMaxGeneratedfilenamelen =16;

#endif

const TInt KBase64MaxLineLength = 64; // chars

const TInt KFileProtocolStringLength = 7; //file://

const TInt KMinFileNameLen = 4; // eg: c:\<1 digit number> , assuming that the property name was zero len. 

// But always the property name will be at least 1 // char in length . 

// This constant used in LoadBinaryValuesFromFilesL() to check whether the URI is fine

_LIT8(KValue,"VALUE");

_LIT8(KUri,"URI");

_LIT(KFileProtocol,"file://");

#define UNUSED_VAR(a) a = a

//

// CParserParam

//

EXPORT_C CParserParam* CParserParam::NewL(const TDesC8& aName,const TDesC8& aValue)

/** Allocates and constructs a new property parameter with the name and value specified.

This object does does not take ownership of aName or aValue.

@param aName The parameter name.

@param aValue The parameter value. Use KNullDesC8 if not applicable.

@return Pointer to the newly created property parameter. */

	{

	HBufC8* paramName=aName.AllocLC();

	HBufC8* value=NULL;

	if (aValue.Length()>0)

		value=aValue.AllocLC();

	CParserParam* param=new(ELeave) CParserParam(paramName,value);

	if (value)

		CleanupStack::Pop(value);

	CleanupStack::Pop(paramName);

	return param;

	}

EXPORT_C CParserParam* CParserParam::NewL(const TDesC8& aName,const TDesC& aValue)

/** Allocates and constructs a new property parameter with the name and value specified.

This object does does not take ownership of aName or aValue.

A Unicode value string is converted to a narrow string for storage. 

@param aName The parameter name.

@param aValue The parameter value. (Use KNullDesC if applicable).

@return Pointer to the newly created property parameter. */

	{

	HBufC8* paramName=aName.AllocLC();

	HBufC8* value=NULL;

	TInt len=aValue.Length();

	if (len>0)

		{

		value=HBufC8::NewLC(len);

		value->Des().Copy(aValue);

		}

	CParserParam* param=new(ELeave) CParserParam(paramName,value);

	if (value)

		CleanupStack::Pop(value);

	CleanupStack::Pop(paramName);

	return param;

	}

EXPORT_C CParserParam::~CParserParam()

/** Frees all resources owned by the property parameter, prior to its destruction. */

	{

	delete iParamName;

	delete iValue;

	}

EXPORT_C void CParserParam::SetValueL(const TDesC8& aValue)

/** Sets the property parameter value.

@param aValue The new property parameter value. */

	{

	delete iValue;

	iValue=0;

	iValue=aValue.AllocL();

	}

EXPORT_C void CParserParam::SetValueL(HBufC8* aValue)

/** Sets the property parameter value.

The property parameter takes ownership of aValue.

@param aValue The new property parameter value. */

	{

	delete iValue;

	iValue=aValue;

	}

EXPORT_C TInt CParserParam::ExternalizeL(RWriteStream& aStream) const

/** Externalises a property parameter to the stream, in the form NAME=VALUE (or just 

NAME, depending on whether there is a value).

This function performs the esacaping of characters.

@param aStream Stream to which the property parameter is to be externalised.

@return The length of data written to the stream. */

	{

	//

	// Write a property parameter in the format of

	//    NAME=VALUE

	//

	aStream.WriteL(*iParamName);

	TInt outputLen=iParamName->Length();

	// If there isn't a VALUE part for this property parameter then just return here...

	if	(!iValue)

		return outputLen;

	// Write the equals...

	aStream.WriteL(KVersitTokenEquals);

	// Escape semi-colon characters

	TInt length = iValue->Length();

	TInt ii;

	TUint8 ch;

	outputLen+=length+1;		//1 for the "="

	for (ii=0;ii<length;++ii)

		{

		ch=(*iValue)[ii];

		if (ch==KVersitTokenSemiColonVal || ch==KVersitTokenBackslashVal)

			{

			aStream.WriteUint8L(KVersitTokenBackslashVal);

			++outputLen;

			}

		aStream.WriteUint8L(ch);

		}

	return outputLen;

	}

EXPORT_C TInt CParserParam::ExternalizeL(RWriteStream& aStream, TInt& aLengthOutput, CVersitParser* aVersitParser) const

/** Externalises vCard3.0 property parameter to the stream, in the form NAME=VALUE or just 

VALUE, if it is a nameless parameter.

This function performs the esacaping of characters. */

	{	

	TBool namelessParam = EFalse;

	/** Property parameter contains value only -> TEL;Home:984536577 in which case iParamName 

	contains the parameter value. */

	HBufC8* buf = NULL;

	TInt nameLen = 0;

	if(iValue == NULL)

		{

		buf = iParamName;

		namelessParam = ETrue;

		}

	else

		{

		buf = iValue;

		nameLen = iParamName->Length()+1; //1 for the "="

		}

	//allocate a buffer large enough to cope with all characters in the string being

	//escaped. If this allocation fails no escaping is attempted which will result in

	//the creation of an invalid vCard

	HBufC8* valueBuf = HBufC8::NewLC(2*buf->Length());	

	TPtr8 valuePtr(valueBuf->Des());

	/** Escape semi-colon,backslash,comma characters in parameter value. */

	const TUint8* pSource = buf->Ptr();

	TInt length = buf->Length();

	for(TInt i = 0; i<length; i++, pSource++) 

		{

		switch (*pSource) 

			{

			case KVersitTokenCommaVal:

				{

				//replace "," with "\,"

				valuePtr.Append(KVersitTokenBackslashVal);

				valuePtr.Append(*pSource);

				}

				break;

			case KVersitTokenSemiColonVal:

				{

				//replace ";" with "\;"

				valuePtr.Append(KVersitTokenBackslashVal);

				valuePtr.Append(*pSource);

				}

				break;

			case KVersitTokenBackslashVal:

				{

				//replace "\" with "\\"	

				valuePtr.Append(KVersitTokenBackslashVal);

				valuePtr.Append(*pSource);

				}

				break;

			default:

				valuePtr.Append(*pSource);

				break;	

			}

		}

	TInt nameValueLen = nameLen + valueBuf->Length();

	HBufC8* nameValue = HBufC8::NewLC(nameValueLen);

	TPtr8 pText(nameValue->Des());	

	if(!namelessParam)

		{

		//create text in the form NAME=VALUE.		

		pText.Append(*iParamName);

		pText.Append(KVersitTokenEqualsVal);

		pText.Append(*valueBuf);

		}

	else

		{

		//nameless parameter.

		pText.Append(*valueBuf);

		}

	//fold property parameter.

	if(aVersitParser->PlugIn())

		{

		aVersitParser->PlugIn()->WrapLine(aStream, aLengthOutput, pText);

		}

	CleanupStack::PopAndDestroy(nameValue);

	CleanupStack::PopAndDestroy(valueBuf);

	return aLengthOutput;

	}

EXPORT_C TPtrC8 CParserParam::Name() const

/** Gets the property parameter name. 

If no name has been set, the function returns an empty string.

@return The property parameter name. */

	{

	if (iParamName)

		return iParamName->Des();

	return KVersitTokenEmptyNarrow();

	}

EXPORT_C TPtrC8 CParserParam::Value() const

/** Gets the property parameter value. 

If no value has been set, the function returns an empty descriptor.

@return The property parameter value. */

	{

	if (iValue)

		return iValue->Des();

	return KVersitTokenEmptyNarrow();

	}

EXPORT_C HBufC* CParserParam::ValueL() const

/** Gets the property parameter value as a Unicode heap descriptor.

If no value has been set, the function returns an empty descriptor.

@return A Unicode version of the property parameter value. */

	{

	TInt len=0;

	if (iValue)

		len=iValue->Length();

	HBufC* value=HBufC::NewL(len);

	if (iValue)

		value->Des().Copy(*iValue);

	return value;

	}

CParserParam::CParserParam(HBufC8* aName,HBufC8* aValue)

	: iParamName(aName)

	, iValue(aValue)

	{}

//

// TVersitDateTime

//

EXPORT_C TVersitDateTime::TVersitDateTime(const TDateTime& aDateTime,TRelativeTime aRelativeTime)

	: iDateTime(aDateTime)

	,iRelativeTime(aRelativeTime)

/** Constructs the Versit date/time object with a date/time value and a specification 

of whether this value is local to the machine which originated the vCard, local 

to the machine on which the code is running, or universal time.

@param aDateTime The date/time value. 

@param aRelativeTime The time the date/time value represents. */

	{

	iFlags = EExportNullFlag;	

	}

//

// CParserPropertyValue

//

EXPORT_C TBool CParserPropertyValue::SupportsInterface(const TUid& /*aInterfaceUid*/) const

/** Tests whether the property value supports the specified interface.

This implementation returns EFalse.

It is implemented by the derived class CParserTimePropertyValue to return ETrue if 

aInterfaceUid is KVersitTimePropertyUid. 

@param aInterfaceUid Not used.

@return EFalse. */

	{

	return EFalse;

	}

GLDEF_C void DestroyHBufC(TAny* aHBufC)

	{

	delete *STATIC_CAST(HBufC**, aHBufC);

	}

EXPORT_C void CParserPropertyValue::FoldEncodeAndWriteValueToStreamL(RWriteStream& aStream, const CDesCArray* aValueArray

														 ,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const

	{

	if (!aValueArray)

		return;

	TInt count=aValueArray->Count();

	if (count==0)

		return;

	TInt bufferLen=64;

	HBufC* unicodeValue = HBufC::NewL(bufferLen);

	TPtr pUnicode(unicodeValue->Des());

	CleanupStack::PushL(TCleanupItem(DestroyHBufC, &unicodeValue));//unicodeValue's address

	TPtrC pValue;

	TInt extraLengthNeeded;

	TInt ii=0;

	FOREVER

		{

		pValue.Set(aValueArray->MdcaPoint(ii));

		extraLengthNeeded=2*pValue.Length()+1+pUnicode.Length()-bufferLen;

		if (extraLengthNeeded>0)

			{

			bufferLen+=32*(1+extraLengthNeeded/32);

			unicodeValue=unicodeValue->ReAllocL(bufferLen);

			pUnicode.Set(unicodeValue->Des());

			}

		VersitUtils::AddEscapedString(pUnicode,pValue,aEncodingCharset.iCharSetId);

		if (++ii==count)

			break;

		pUnicode.Append(KVersitTokenSemiColonUnicode);

		}

	if (iPlugIn)

		iPlugIn->AddEscaping(unicodeValue);

	FoldAndWriteValueToStreamL(aStream,*unicodeValue,aEncodingCharset,aLengthOutput);

	CleanupStack::PopAndDestroy(&unicodeValue);

	}

EXPORT_C void CParserPropertyValue::FoldEncodeAndWriteValueToStreamL(RWriteStream& aStream, const TDesC& aValue

														,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const

	{

	TInt length = aValue.Length();

	if	(!length)

		return;

	HBufC* unicodeValue = HBufC::NewL(2*length);

	TPtr pUnicode(unicodeValue->Des());

	CleanupStack::PushL(TCleanupItem(DestroyHBufC, &unicodeValue));

	VersitUtils::AddEscapedString(pUnicode,aValue,aEncodingCharset.iCharSetId);

	if (iPlugIn)

		iPlugIn->AddEscaping(unicodeValue);

	FoldAndWriteValueToStreamL(aStream,*unicodeValue,aEncodingCharset,aLengthOutput);

	CleanupStack::PopAndDestroy(&unicodeValue);

	}

EXPORT_C void CParserPropertyValue::FoldAndWriteValueToStreamL(RWriteStream& aStream, const TDesC& aValue

														,const Versit::TEncodingAndCharset& aEncodingCharset,TInt& aLengthOutput) const

	{

	__ASSERT_DEBUG(aEncodingCharset.iEncoding!=Versit::EEightBitEncoding, Panic(EVersitPanicUnexpectedEightBitEncoding));

	HBufC8* narrowBuffer = HBufC8::NewLC(3*aValue.Length());

	TPtr8 pText(narrowBuffer->Des());

	VersitUtils::UncodeToNarrowL(aValue,pText,aEncodingCharset);

	CBufFlat* buffer=NULL;

	if (aEncodingCharset.iEncoding!=Versit::ENoEncoding)

		{

		buffer=CBufFlat::NewL(3*pText.Length()/2);

		CleanupStack::PushL(buffer);

		TUid encodingUid = VersitUtils::ConArcEncodingUid(aEncodingCharset.iEncoding);

		EncodeL(buffer,*narrowBuffer,encodingUid);

		pText.Set(buffer->Ptr(0));

		if (aEncodingCharset.iEncoding==Versit::EBase64Encoding)

			{

			if (pText.Length()+aLengthOutput>KMaxExternalizedTokenLength)

				VersitUtils::WrapLinesL(*buffer, KBase64MaxLineLength);

			buffer->InsertL(buffer->Size(), KVersitTokenCRLF);

			pText.Set(buffer->Ptr(0));

			}

		else

			{

			TInt firstLineLine=pText.Find(KVersitTokenCRLF);

			if (firstLineLine+aLengthOutput>KMaxExternalizedTokenLength)

				{

				aStream.WriteL(KVersitTokenEquals);

				aStream.WriteL(KVersitTokenCRLF);

				}

			}

		aStream.WriteL(pText);

		aLengthOutput=0;		//aLengthOutput should not be used again when encoding is Quoted-Printable

		CleanupStack::PopAndDestroy(buffer);

		}

	else if (!iPlugIn || !iPlugIn->WrapLine(aStream,aLengthOutput,pText))

		{

		TPtr8 searchString(NULL,0,0);

		TInt lineLength=Max(KMaxExternalizedTokenLength-aLengthOutput,0);

		TInt lengthLeft=pText.Length();

		TInt searchPos;

		while (lengthLeft>lineLength)

			{

			searchPos=lineLength;

			while (searchPos>=0 && pText[searchPos]==CVersitParser::ESpace)		//Search for last non-space before wrapping length

				--searchPos;

			if (searchPos>0)

				{

				searchString.Set(&pText[0],searchPos,searchPos);

				searchPos=searchString.LocateReverse(CVersitParser::ESpace);	//If there is one search for a space before that

				}

			else

				searchPos=KErrNotFound;

			if (searchPos==KErrNotFound)		//If can't break before wrapping length find first suitable place after it

				{

				searchPos=lengthLeft-lineLength;

				searchString.Set(&pText[lineLength],searchPos,searchPos);

				searchPos=lineLength+searchString.Locate(CVersitParser::ESpace);

				if (searchPos<lineLength)

					break;		//No more spaces

				while (searchPos<lengthLeft && pText[searchPos]==CVersitParser::ESpace)

					++searchPos;

				--searchPos;

				}

			searchString.Set(&pText[0],searchPos,searchPos);

			aStream.WriteL(searchString);

			aStream.WriteL(KVersitLineBreak);

			aLengthOutput=2;

			lengthLeft-=++searchPos;

			if (lengthLeft==0)

				{

				pText.Set(NULL,0,0);

				break;

				}

			pText.Set(&pText[searchPos],lengthLeft,lengthLeft);

			lineLength=KMaxExternalizedTokenLength;

			}

		aLengthOutput+=pText.Length();

		aStream.WriteL(pText);

		}

	CleanupStack::PopAndDestroy(narrowBuffer);

	}

EXPORT_C CParserPropertyValue::CParserPropertyValue(const TUid& aPropertyValueUid)

	: iPropertyValueTypeUid(aPropertyValueUid)

	{}

EXPORT_C TBool CParserPropertyValue::IsAsciiCharacterSetSufficient()

/** Tests whether the Ascii character set is sufficient to represent a property 

value.

This implementation returns ETrue.

It is overridden by classes CParserPropertyValueAlarm, CParserPropertyValueHBufC 

and CParserPropertyValueCDesCArray.

This function is called by CParserProperty::ExternalizeL().

@return ETrue. */

	{

	return ETrue;

	}

EXPORT_C void CParserPropertyValue::EncodeL(CBufBase* aTarget,const TDesC8& aSource,const TUid& aEncoding) const

/** Encodes the text property value referred to in aSource, if encoding is required.

Uses the encoding format identified by aEncoding. This is only used for 

text property values (e.g. HBufC or DesCArray property types). 

Invoked by implementations of ExternalizeL().

@param aTarget A pointer to the buffer which will have the converted text 

written into it.

@param aSource The source text.

@param aEncoding An encoding UID. The possible encoding formats are defined 

in vuid.h. Specify NULL UID if no encoding is required. */

	{

	__ASSERT_DEBUG(aTarget, User::Invariant());

	RDesReadStream readStream(aSource);