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

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <versitlinereaderext.h>

#include "versittlscontainer.h"

#include "versit_internal.h"

#endif

// System includes

#include <s32file.h>

#include <s32mem.h>

#include <utf.h>

#include <charconv.h>

#include <confndr.h>

#include <concnf.h>

#include <conlist.h>

#include <e32base.h>

// User includes

#include <vutil.h>

#include <vstaticutils.h>

#include <versittls.h>

#include "verror.h"

#include <vobserv.h>

#include <vcal.h>

#include "VersitAdditionalStorage.h"

// Constants

_LIT8(KReplacementChars, "?");

const TInt KVersitDatePropertySymbianConnectMessageMaximumLenght=1;

#define UNUSED_VAR(a) a = a

//

// CLineReader

//

EXPORT_C CLineReader* CLineReader::NewL(RReadStream& aStream)

/** Constructs and returns a CLineReader.

@param aStream The stream to read the lines from. */

	{

	CLineReader* self=new(ELeave) CLineReader(aStream);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C void CLineReader::ConstructL()

	{

	iSkipWhiteSpaceAtStart=ETrue;

	iLineBuf=HBufC8::NewL(EInitialLineSize);

	iBufPtr=iLineBuf->Des();

#if defined(__VC32__)

	iBufPtr.Set(iLineBuf->Des());    // workaround for VC6 bug

#endif

	iExtension=CLineReaderExtension::NewL();

	}

EXPORT_C CLineReader::~CLineReader()

/** Frees all resources owned by the line reader prior to its destruction. */

	{

	delete iLineBuf;

	if (iExtension && iReadStream)

		{

		if (iExtension->iSize - iExtension->iOffset > 0)

			{

			// there is data in the buffer that has not yet been parsed

			// so we must adjust the seek pointer for the input stream to

			// point exactly to the end of the data that has been parsed

			// so that the rest will be re-read when the file is next accessed.

			// The traps are neccesary because a destructor can't leave.

			MStreamBuf* source = iReadStream->Source();

			if (source != NULL)

				{

				TStreamPos pos(0);

				TRAPD(err, pos = source->TellL(MStreamBuf::ERead));

				if (err == KErrNone)

					{

					pos -= (iExtension->iSize - iExtension->iOffset);

					TRAP(err, source->SeekL(MStreamBuf::ERead, pos));

					}

				}

			}

		}

	delete iExtension;

	}

/** Read base64 multiple lines

This should be only called when parsing multi-line base64 data, and the interface 

MVersitPlugInExtensionBase64Ending::BlankLineAndLeadingSpaceNotRequired returns ETrue 

If the character ':' is not contained in the current line,we know it is base64 value.It is therefore appended to

iBufPtr. Otherwise we know it is a new property which will be held in CLineReaderExtension::iLineBase64Value 

temporarily until the next propery is to be parsed.

@param aPosValueStart The position in the iLineBuffer where base64 value starts 

*/	

void CLineReader::ReadBase64ValueL(TInt aPosValueStart)

	{

	HBufC8* base64Buffer = iExtension->CreateBase64ValueBufferL();//Creat a buffer to hold a

	iBufPtr.Delete(0, aPosValueStart);//To make sure iBufPtr only contains base64 value	

	TInt err = KErrNone;

	TInt ret = ELineIsWhiteSpace;

	TPtr8 ptr = base64Buffer->Des();

	while (ret != ELineHasColon)

		{

		__ASSERT_DEBUG(ret==ELineHasContent ||ret==ELineIsWhiteSpace||ret==ELineIsCRLFOnly, Panic(ECurrentTokenNotFound));

		if (ret == ELineHasContent)

			{

			iLineBuf = iLineBuf->ReAllocL(iLineBuf->Length() + ptr.Length());

			iBufPtr.Set(iLineBuf->Des());	

			iBufPtr.Append(ptr);

			}

		ptr.SetLength(0);

		ret = ReadLineL(base64Buffer, 0, err);

		ptr.Set(base64Buffer->Des());

		}

	}

/** Reads in a line from the stream.

The line is stored in a buffer pointed to by iBufPtr. Data from the stream 

is appended to the buffer, starting at buffer position aPos, until the next 

'CRLF' ("/r/n") is reached. The line feed and carriage return are not added 

to the buffer. Using only linefeeds LF(\n) as the line delimiters is also supported.

The buffer will be expanded if necessary to fit the line into it. 

If the end of stream is reached, aErr will contain KErrEof upon return.

It would be normal to set aPos to the start of the buffer unless reading a 

multi-line value.

@param aPos The position in the buffer pointed to by iBufPtr at which to begin 

appending data to the buffer. Allows lines to be appended to the buffer when 

reading multi-line values.

@param aErr On return, this will be KErrEof if the end of the stream is reached 

and KErrNone otherwise.

@return ELineHasContent if the line has content; ELineIsWhiteSpace if the line 

has only white space before the CRLF; ELineIsCRLFOnly if the line is only 

a CRLF. 

*/

EXPORT_C TInt CLineReader::ReadLineL(TInt aPos,TInt& aErr)

	{

	TInt ret = ELineHasContent;

	HBufC8* base64Buffer = iExtension->Base64ValueBuffer();

	if(aPos==0 && base64Buffer && base64Buffer->Length()>0)

		{//If the base64Buffer is not empty, we know the current line has

		// already been read and the data is held in CLineReaderExtension::iLineBase64Value

		// for a new property (see ReadBase64ValueL)

		if(iBufPtr.MaxLength() < base64Buffer->Length())

			{

			iLineBuf = iLineBuf->ReAllocL(base64Buffer->Length());

			}

		*iLineBuf = *base64Buffer;

		iBufPtr.Set(iLineBuf->Des());

		iBufPtr.SetLength(base64Buffer->Length());

		iExtension->DeleteBase64ValueBuffer();

		}

	else //Otherwise read the current line

		{

		ret = ReadLineL(iLineBuf, aPos, aErr);

		if(ret == ELineHasColon)

			{

			ret = ELineHasContent;//For the sake of backwards compatability - ELineHasColon is only used by ReadBase64ValueL. 

			}

		iBufPtr.Set(iLineBuf->Des());

		}

	return ret;

	}

TInt CLineReader::ReadLineL(HBufC8*& aHBuf, TInt aPos,TInt& aErr)

/** Reads in a line from the stream.

The line is stored in a buffer pointed to by aHBuf. Data from the stream 

is appended to the buffer, starting at buffer position aPos, until the next 

'CRLF' ("/r/n") is reached. The line feed and carriage return are not added 

to the buffer. Using only linefeeds LF(\n) as the line delimiters is also supported.

The buffer will be expanded if necessary to fit the line into it. 

If the end of stream is reached, aErr will contain KErrEof upon return.

It would be normal to set aPos to the start of the buffer unless reading a 

multi-line value.

@param aPos The position in the buffer pointed to by aHBuf at which to begin 

appending data to the buffer. Allows lines to be appended to the buffer when 

reading multi-line values.

@param aErr On return, this will be KErrEof if the end of the stream is reached 

and KErrNone otherwise.

@return 

ELineHasContent if the line has content;

ELineIsWhiteSpace if the line has only white space before the CRLF;

ELineIsCRLFOnly if the line is only a CRLF.

EELineHasColon If character ':' contained in the line

*/

	{

	TInt crPos=-1;

	TUint8 ch=STATIC_CAST(TUint8,iFirstCharNextLine);

	TInt whiteSpaceLine=ELineIsCRLFOnly;

	TBool truncateLine=ETrue;

	TBool skipWhiteSpaceAtStart=iSkipWhiteSpaceAtStart;

	TPtr8 ptrHbuf = aHBuf->Des();

	ptrHbuf.SetLength(aPos);

	if (iFirstCharNextLine>=0)

		{

		iFirstCharNextLine=-1;

		goto CharacterRead;

		}

	FOREVER

		{

		ch=ReadChar(aErr);

		if (aErr!=KErrEof)

			User::LeaveIfError(aErr);

		else

			{

			crPos=aPos-1;

			while (crPos>=0 && (ptrHbuf[crPos]==CVersitParser::ELineFeed || ptrHbuf[crPos]==CVersitParser::ECarriageReturn))

				{

				--crPos;

				}

			truncateLine=(++crPos<aPos);

			break;

			}

	CharacterRead:

		if (ch==CVersitParser::ECarriageReturn)

			{

			if (crPos<0)

				crPos=aPos;

			skipWhiteSpaceAtStart=EFalse;

			// next character should be a LF...

			}

		else if (ch==CVersitParser::ELineFeed)

			{

			if (crPos<0)

				{

				// LF without CR

				crPos=aPos;

				skipWhiteSpaceAtStart=EFalse;

				}		

			break; // The end of a line.

			}

		else 

			{

			crPos=-1;

			if (whiteSpaceLine == ELineIsWhiteSpace || whiteSpaceLine == ELineIsCRLFOnly )

				{

				whiteSpaceLine=(VersitUtils::IsWhiteSpace(ch) ? ELineIsWhiteSpace:ELineHasContent);

				if (!whiteSpaceLine)

					skipWhiteSpaceAtStart=EFalse;

				}

			if (ch == CVersitParser::EColon)

				{

				whiteSpaceLine = ELineHasColon;

				}

			}

		if (skipWhiteSpaceAtStart)

			{

			if (iPlugIn)

				skipWhiteSpaceAtStart=iPlugIn->DeleteAllSpaces();

			}

		else

			{

			if (aPos==ptrHbuf.MaxLength())

				{

				aHBuf=aHBuf->ReAllocL(aPos+EExpandSize);

				ptrHbuf.Set(aHBuf->Des());

				}

			++aPos;

			ptrHbuf.Append(ch);

			}

		}

	if (truncateLine)

		ptrHbuf.SetLength(crPos);

	return whiteSpaceLine;

	}

EXPORT_C TBool CLineReader::AppendLineIfSpaceNextL()

/** Checks the first character of the next line and, if it is a white space, reads 

the next line into the buffer (pointed to by iBufPtr).

The line is appended to the buffer rather than overwriting data already in 

the buffer.

A plug-in option can determine that no space is to be written to the buffer 

between the lines. By default, a space will be written.

Used by the Versit parser while it is reading multi-line property values.

@return ETrue if a line was read (because the first character of the next 

line is a space); EFalse if a line wasn't read (because the first character 

of the next line isn't a space or an error occured). */

	{

	TInt err=KErrNone;

	if (iFirstCharNextLine<0)

		iFirstCharNextLine=ReadChar(err);

	if (err!=KErrNone || !VersitUtils::IsWhiteSpace(iFirstCharNextLine))

		return EFalse;

	TInt len;

	if (iPlugIn && !iPlugIn->AddSpace())

		len=iBufPtr.Length();

	else

		len=AppendSpaceL();

	ReadLineL(len,err);

	return ETrue;

	}

EXPORT_C TBool CLineReader::IsSpaceNextL()

/** Checks to see if the first character of the next line is white space.

This function should not be called more than once without a line being read 

in.

Used by the Versit parser while it is reading multi-line property values.

@return ETrue if the next line starts with a white space character; EFalse 

if it doesn't or an error occurs. */

	{

	TInt err;

	iFirstCharNextLine=ReadChar(err);

	return (err==KErrNone && VersitUtils::IsWhiteSpace(iFirstCharNextLine));

	}

EXPORT_C TInt CLineReader::AppendSpaceL()

/** Appends a space to the end of the buffer (pointed to by iBufPtr).

The buffer will be expanded if necessary.

This is called by AppendLineIfSpaceNextL() to create a space in the buffer 

between the lines being read (as long as there is no plug-in option to to 

indicate there should be no space).

@param The length of the buffer after the space has been added. */

	{

	TInt len=iBufPtr.Length();

	if (len==iBufPtr.MaxLength())

		ExpandBufferL(len);

	iBufPtr.Append(CVersitParser::ESpace);

	return len+1;

	}

EXPORT_C void CLineReader::ExpandBufferL(TInt aCurrentSize)

	{

	iLineBuf=iLineBuf->ReAllocL(aCurrentSize+EExpandSize);

	iBufPtr.Set(iLineBuf->Des());

	}

EXPORT_C TUint8 CLineReader::ReadChar(TInt& aErr)

	{

	// Return the next character from the read buffer. If it is the

	// end of the buffer or it is empty then refill the buffer.

	aErr = KErrNone;

	if (iExtension->iOffset >= iExtension->iSize)

		{

		iExtension->iOffset = 0;

		MStreamBuf* source = iReadStream->Source();

		TRAP(aErr, iExtension->iSize = source->ReadL(iExtension->iBuf, 1024));

		if (aErr != KErrNone)

			{

			return 0;

			}

		if (iExtension->iSize == 0)

			{

			aErr = KErrEof;

			return 0;

			}

		}

	return iExtension->iBuf[iExtension->iOffset++];

	}

EXPORT_C void CLineReader::Reserved()

	{}

//

// CVersitParser

//

EXPORT_C CVersitParser::CVersitParser(TUint aFlags) : iFlags(aFlags)

/** The first phase constructor for a Versit parser. 

Sets the default encoding to Versit::ENoEncoding and the default character 

set to Versit::EUSAsciiCharSet.

Note: this function is called by the CParserVCal and CParserVCard constructors. It 

should only be called directly by a user if creating a new parser

@param aFlags The flag to indicate whether this entity needs a version property. 

The possible values for this flag are given in the TVersitParserFlags enumeration. 

If a version property is needed, one will be created and appended to the 

start of the array of properties. */

	{

	SetDefaultEncoding(Versit::ENoEncoding);

	SetDefaultCharSet(Versit::EUSAsciiCharSet);

	RestoreLineCodingDetailsToDefault();

	}

void CloseTlsData(TAny *aData)

	{

	CVersitTlsData *data = static_cast<CVersitTlsData *>(aData);

	data->CloseVersitTlsData();

	}

EXPORT_C void CVersitParser::ConstructL()

/** The second phase constructor for a Versit parser.

Stores a pointer to a CVersitTlsData (thread local storage data class). This 

is used to allow an instance of CVersitUnicodeUtils to be shared by all co-existing 

parsers, which provides a major performance improvement.

Called by the CParserVCal and CParserVCard constructors.

Should only be called directly by a user if creating a new parser. */

	{

	_LIT8(KEscapeCharacter8, "\\");

	iStaticUtils=&CVersitTlsData::VersitTlsDataL();

	//query charconv for the plugin dependant shift-jis escape character, 

	//store in TLS to be accessed by versit static utils

	CCnvCharacterSetConverter::TAvailability avail=UnicodeUtils().SetCurrentCharSetL(KCharacterSetIdentifierShiftJis);

	if (avail == CCnvCharacterSetConverter::EAvailable)

		{

		// Do the conversion

		CCnvCharacterSetConverter& converter=UnicodeUtils().CharacterSetConverter();

		TInt ignore = 0;

		converter.SetReplacementForUnconvertibleUnicodeCharactersL(KReplacementChars);

		CVersitTlsData& data = CVersitTlsData::VersitTlsDataL();

		CleanupStack::PushL( TCleanupItem( CloseTlsData, &data ) );

		CVersitAdditionalStorage& additionalStorage = data.AdditionalStorage();

		CBase* storedValue = additionalStorage.FromStorage(KTLSVars);

		if( NULL == storedValue )

			{

			CVersitTLSContainer *tlsContainer = CVersitTLSContainer::NewLC(2);

			TPtrC8 ptr8 = KEscapeCharacter8();

			TPtr ptr16( tlsContainer->iShiftJisEscape->Des() );

			converter.ConvertToUnicode(ptr16, ptr8, ignore);

			additionalStorage.AddToStorageL(KTLSVars, tlsContainer);

			CleanupStack::Pop( tlsContainer );

			}

		CleanupStack::PopAndDestroy();//data

		}

	}

EXPORT_C CVersitParser::~CVersitParser()

// Note: CVersitParser never owns iReadStream/iWriteStream

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

	{

	if (iArrayOfEntities)

		{

		iArrayOfEntities->ResetAndDestroy();

		delete iArrayOfEntities;

		}

	if (iArrayOfProperties)

		{

		iArrayOfProperties->ResetAndDestroy();

		delete iArrayOfProperties;

		}

	delete iCurrentProperty;

	delete iEntityName;

	delete iOwnedLineReader;

	delete iLargeDataBuf;

	delete iDecodedValue;

	// Close any TLS storage

	if (iStaticUtils)

		iStaticUtils->VersitTlsDataClose();

	}

EXPORT_C void CVersitParser::InternalizeL(RFile& aInputFile,TInt& aBytesThroughFile)

/** Internalises a versit entity (vCard or vCalendar) and all of its

sub-entities and properties from a file.

Stores all date/time in same format as received

@param aInputFile  The file from which to internalise the entity.

@param aBytesThroughFile The number of bytes into the file at which to begin 

reading. On return, is updated to contain the last position in the file which 

was read.

@leave KErrEof The file position specified is beyond the end of the file. */

	{

	TInt size;

	if (aInputFile.Size(size)==KErrNone)

		{

		RFileReadStream stream(aInputFile,aBytesThroughFile);

		TInt size=stream.Source()->SizeL();

		TRAPD(err,InternalizeL(stream));

		if (err==KErrNone)

			TRAP(err,aBytesThroughFile+=(size-stream.Source()->SizeL()));

		STATIC_CAST(RFileBuf*,stream.Source())->Reset();

		stream.Close();

		User::LeaveIfError(err);

		}

	}

EXPORT_C void CVersitParser::InternalizeL(RReadStream& aStream)

/** Internalises a Versit entity (vCard or vCalendar) contained in the incoming stream 

and parses it, breaking it down into its constituent sub-entities (e.g. to-dos,