// 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 <s32file.h>

#include <s32mem.h>

#include <bassnd.h>

#include <calentry.h>

#include <vtzrules.h>

#include "agnversit.h"

#include <utf.h>

#include <tz.h> //Conversion between local and UTC times

#include <calalarm.h>

#include <calcontent.h>

#include <calrrule.h>

#include <caluser.h>

#include <calattachment.h>

#include "agmvcal.h"

const TInt KCountDigits = 8;

_LIT(KDateStringFormat, "%F%D%M%Y%H%T%S%C"); // locale-independent formatting DDMMYYHHMMSSUUUUUU (day,month,year,hour,minute,second,usec

_LIT(KVersitTokenMailTo,"MAILTO:");

HBufC* AgnConvertUtil::EncodeL(const TDesC& aText,TUid aConversion)

	{

	HBufC8* text=HBufC8::NewLC(aText.Length()*2);

	TPtr8 ptr = text->Des();

	TInt i;

	for (i=0; i < aText.Length(); i++)

		{

		ptr.Append(aText[i] & 0x00FF);

		ptr.Append((aText[i] >> 8) & 0x00FF);

		}

	CCnaConverterList* convList=CCnaConverterList::NewLC(); 

	CConverterBase* conv = convList->NewConverterL(aConversion); 

	if (!conv)

		{

		CleanupStack::PopAndDestroy();          // convList 

		User::Leave(KErrNotSupported);

		}

	CleanupStack::PushL(conv);

	CBufFlat* decodeBuffer = CBufFlat::NewL(256); 

	CleanupStack::PushL(decodeBuffer);

	CBufFlat* encodedBuffer = CBufFlat::NewL(256); 

	CleanupStack::PushL(encodedBuffer);

	decodeBuffer->InsertL(0,ptr);

	RBufReadStream readStream;

	RBufWriteStream writeStream;

	readStream.Open(*decodeBuffer);

	writeStream.Open(*encodedBuffer);

	conv->ConvertObjectL(readStream, writeStream); 

	readStream.Close();

	TInt size=encodedBuffer->Size();

	HBufC* writeBuf=HBufC::NewLC(size); 

	TPtr resulttext = writeBuf->Des();

	for(i = 0; i < (size - 1); i += 2)

		{

		resulttext.Append((encodedBuffer->Ptr(0)[i + 1] << 8) | 

			encodedBuffer->Ptr(0)[i]);

		}

	writeStream.CommitL();

	writeStream.Close();

	CleanupStack::Pop(writeBuf); // writebuf

	CleanupStack::PopAndDestroy(2,decodeBuffer); // buffers 

	CleanupStack::PopAndDestroy(2,convList); //conv+convList

	CleanupStack::PopAndDestroy(text);  //text

	return (writeBuf);

	}

// This method imports a vCalendar entity from aParser and returns a pointer to a CAgnEntry

// if successful or NULL if it wasn't possible to import the vCalendar. It reads the

// relevant properties from aParser entity and builds up a corresponding agenda entry.

// It allows to import vCal file without Summary and Description fields

void CVCalToAgendaEntryConverter::ImportVCalL(CVersitParser& aParser, RPointerArray<CCalEntry>& aEntryArray)

	{

	CCalEntry::TType entryType = GetEntryTypeL(aParser);

		// Group Scheduling Data

	//Import UID

	HBufC* guid16 = ImportDesPropertyL(aParser, KVersitTokenUID);

	if (!guid16) // non cal entry 

		{

		// create our a UID based on the current time (UTC, microsecond precision)

		TTime now;

		now.UniversalTime();  

		TBuf<KMaxTimeStringSize+KCountDigits> dateString;

		now.FormatL(dateString,KDateStringFormat);

		TInt threeDidgit=Math::Random() % 1000;

		dateString.Append(threeDidgit);

		guid16 = dateString.AllocL();	

		}

	CleanupStack::PushL(guid16);

	// the UID is stored as an 8-bit descriptor, so convert from 16-bit to 8-bit

	HBufC8* guid8= CnvUtfConverter::ConvertFromUnicodeToUtf8L(guid16->Des());				 

	CleanupStack::PopAndDestroy(guid16);  

	CleanupStack::PushL(guid8);		

	// Import Sequence Number

	TInt seqNumber;	

	// if no sequence number

	if (!ImportIntegerPropertyL(aParser, KVersitTokenSEQUENCE, seqNumber))

		{

		seqNumber = 0;

		}

	// Import Method

	CCalEntry::TMethod methodStatus(CCalEntry::EMethodNone);

	HBufC* method = ImportDesPropertyL(aParser, KVersitTokenXMETHOD);

	if (method)

		{

		CleanupStack::PushL(method);

		if (*method == KVCalTokenMethodStatusENone)	

			{

			methodStatus = CCalEntry::EMethodNone;

			}

		else if (*method == KVCalTokenMethodStatusEPublish)	

			{

			methodStatus = CCalEntry::EMethodPublish;

			}

		else if (*method == KVCalTokenMethodStatusERequest)	

			{

			methodStatus = CCalEntry::EMethodRequest;

			}

		else if (*method == KVCalTokenMethodStatusEReply)	

			{

			methodStatus = CCalEntry::EMethodReply;

			}

		else if (*method == KVCalTokenMethodStatusEAdd)	

			{

			methodStatus = CCalEntry::EMethodAdd;

			}

		else if (*method == KVCalTokenMethodStatusECancel)	

			{

			methodStatus = CCalEntry::EMethodCancel;

			}

		else if (*method == KVCalTokenMethodStatusERefresh)	

			{

			methodStatus = CCalEntry::EMethodRefresh;

			}

		else if (*method == KVCalTokenMethodStatusECounter)	

			{

			methodStatus = CCalEntry::EMethodCounter;

			}

		else if (*method == KVCalTokenMethodStatusEDeclineCounter)	

			{

			methodStatus = CCalEntry::EMethodDeclineCounter;

			}

		else

			{

			// do nothing if method is invalid - it will be None by default

			}	

		CleanupStack::PopAndDestroy(method);

		}		

	// Import X-Recurrence-Id

	TVersitDateTime::TRelativeTime relativeTime = TVersitDateTime::EIsUTC;

	TTime recurrenceId;

	TBool isRecurrenceIdPresent = ImportDateTimePropertyL(aParser, KVersitTokenXRECURRENCEID, recurrenceId, relativeTime);

	if (!isRecurrenceIdPresent)

		{

		iEntry = CCalEntry::NewL(entryType,guid8, methodStatus, seqNumber);

		}

	else

		{

		TCalTime caltime;

		if(GetTimeModeL(aParser) == TCalTime::EFloating)

			{

			caltime.SetTimeLocalFloatingL(recurrenceId);

			}

		else

			{

			caltime.SetTimeUtcL(recurrenceId);

			}

		iEntry = CCalEntry::NewL(entryType,guid8, methodStatus, seqNumber, caltime, CalCommon::EThisOnly);

		}

	CleanupStack::Pop(guid8); // ownership was passed to calGSData	

	// Fill in the entry description from the SUMMARY property

	// If this doesn't exist, use the DESCRIPTION property, and if this

	// doesn't exist, return a NULL entry

 	// get properties but don't take ownership of the elements of the array

 	CArrayPtr<CParserProperty>* properties = aParser.PropertyL(KVersitTokenSUMMARY, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

	if (!properties)

		{

		// get properties but don't take ownership of the elements of the array

		properties = aParser.PropertyL(KVersitTokenDESCRIPTION, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

		}

	CleanupStack::PushL(properties);

	// Use the value found from the Summary/Description 

	// Both Summary and Description are not found in imported vCal file 

	//then insert empty enties for summary and description

	//  these empty entries will be descarded while exporting vCal file

	TPtrC summary;

	if (properties)

		{

		summary.Set(static_cast<CParserPropertyValueHBufC*>((*properties)[0]->Value())->Value());

		}

	HBufC* summaryBuf = AgnConvertUtil::EncodeL(summary,KUidTextToEtextNoTrim);

	CleanupStack::PushL(summaryBuf);

	if (summaryBuf)

		{

		iEntry->SetSummaryL(*summaryBuf);

		}

	CleanupStack::PopAndDestroy(summaryBuf);

	HBufC* description =ImportDesPropertyL(aParser,KVersitTokenDESCRIPTION);

	CleanupStack::PushL(description);

	if (description != NULL)

		{

		iEntry->SetDescriptionL(*description); // Takes ownership

		}

	CleanupStack::PopAndDestroy(description);

	TBool validEntry = EFalse;

	if (entryType == CCalEntry::ETodo)

		{

		validEntry = ImportTodoPropertiesL(aParser);

		}

	else

		{

		validEntry = ImportEventPropertiesL(aParser);

		}

	if (!validEntry)

		{

		CleanupStack::PopAndDestroy(properties);

		delete iEntry;

		iEntry = NULL;

		return;

		}

	// Import CLASS property

	HBufC* property=ImportDesPropertyL(aParser, KVersitTokenCLASS);

	if (property)

		{

		CleanupStack::PushL(property);

		if (*property == KVCalTokenPUBLIC)

			iEntry->SetReplicationStatusL(CCalEntry::EOpen);

		else if (*property == KVCalTokenPRIVATE)

			iEntry->SetReplicationStatusL(CCalEntry::EPrivate);

		else if (*property == KVCalTokenCONFIDENTIAL)

			iEntry->SetReplicationStatusL(CCalEntry::ERestricted);

		CleanupStack::PopAndDestroy(property);

		}

	// Import LOCATION property

	property=ImportDesPropertyL(aParser, KVersitTokenLOCATION);

	if (property)

		{

		CleanupStack::PushL(property);

		iEntry->SetLocationL(*property);

		CleanupStack::PopAndDestroy(property);

		}

	// Import DTSTAMP

	TTime timeProperty;

	if (ImportDateTimePropertyL(aParser, KVersitTokenXDTSTAMP, timeProperty, relativeTime))

		{

		TCalTime caltimeProperty;

		caltimeProperty.SetTimeUtcL(timeProperty);

		iEntry->SetDTStampL(caltimeProperty);

		}

	// Attendee property

 	ImportAttendeePropertiesL(aParser, KVersitTokenATTENDEE);

	// Categories property

	ImportCategoriesPropertyL(aParser, KVersitTokenCATEGORIES);

	TInt localId;

	if (ImportIntegerPropertyL(aParser, KVersitTokenXLOCALUID, localId))

		{

		iEntry->SetLocalUidL(localId);

		}

	// Additional stuff to comply with Versit Specs 1.0  

	// All entries have a priority not just ToDo's

	// Todo Functionality merged into this code block

	TInt priority;

	if (ImportIntegerPropertyL(aParser, KVersitTokenPRIORITY, priority))

		{

		iEntry->SetPriorityL(priority);  

		}

	// All entries have a status - will default to Needs Action if cannot be read

	CCalEntry::TStatus entryStatus=CCalEntry::ENullStatus;

	ImportStatusPropertyL(aParser, entryStatus);

	//Now sync completed and ECompleted status to keep entry consistenty 

	if(entryType==CCalEntry::ETodo && (iEntry->CompletedTimeL().TimeUtcL()) != Time::NullTTime())

		{

		iEntry->SetCompletedL(ETrue, iEntry->CompletedTimeL());

		}

	iEntry->SetStatusL(entryStatus);

	//Get last changed date from vcal

	if (ImportDateTimePropertyL(aParser, KVersitTokenLASTMODIFIED, timeProperty, relativeTime))

			{

			if (iTzZone && (relativeTime == TVersitDateTime::EIsVCardLocal))

				{

				iTzZone->ConvertToUtcL(timeProperty);

				}

			TCalTime lastModifiedDate;

			lastModifiedDate.SetTimeUtcL(timeProperty);

			iEntry->SetLastModifiedDateL(lastModifiedDate);

			}

		else

			{

			iEntry->SetLastModifiedDateL(); //set changed date to now

			}

	TInt transp;

	if (ImportIntegerPropertyL(aParser, KVersitTokenTRANSP, transp))

		{

		iEntry->SetTimeTransparencyL(static_cast<CCalEntry::TTransp>(transp));

		}

	ImportAttachmentPropertyL(aParser);

	// Import GEO

	HBufC* geoString=ImportDesPropertyL(aParser,KVersitTokenGEO);

	if (geoString != NULL)

		{

		CleanupStack::PushL(geoString);

		// Determine the position of the delimiter for extraction of the geo latitude and longitude values

		TInt delimiterPos = geoString->Locate(KVersitTokenCommaVal);

		if(delimiterPos!=KErrNotFound)

			{

			// Extract the latitude

			TLex geoLatitudeLex(geoString->Left(delimiterPos));

			// Extract the latitude by excluding the delimiter

			TLex geoLongitudeLex(geoString->Right(geoString->Length()-(delimiterPos+1)));

			TReal geoLatitude;

			TReal geoLongitude;

			if((geoLatitudeLex.Val(geoLatitude)==KErrNone) && (geoLongitudeLex.Val(geoLongitude)==KErrNone))

				{

				CCalGeoValue* importedGeoValue=CCalGeoValue::NewL();

				CleanupStack::PushL(importedGeoValue);

				TRAPD(err, importedGeoValue->SetLatLongL(geoLatitude,geoLongitude));

				if(err==KErrNone)

					{

					iEntry->SetGeoValueL(*importedGeoValue);

					}

				CleanupStack::PopAndDestroy(importedGeoValue);

				}

			}

		CleanupStack::PopAndDestroy(geoString);

		}

	CleanupStack::PopAndDestroy(properties);

	aEntryArray.AppendL(iEntry); // takes ownership of entry

	iEntry = NULL;

	}

CVCalToAgendaEntryConverter::~CVCalToAgendaEntryConverter()

	{

	delete iEntry;

	delete iTzZone;

	}

void CVCalToAgendaEntryConverter::SetTzConverter(RTz* aTzConverter)

	{

	iTzConverter = aTzConverter;

	}

void CVCalToAgendaEntryConverter::SetTzRules(CTzRules* aTzZone)

	{

	// this function should only ever be called once so this shouldn't be needed

	if (iTzZone)

		{

		delete iTzZone;

		iTzZone = NULL;

		}

	iTzZone = aTzZone;

	}

TCalTime::TTimeMode CVCalToAgendaEntryConverter::GetTimeModeL(CVersitParser& aParser)

	{

	TTime dummyTime;

	TVersitDateTime::TRelativeTime relativeTime;

	if ( ! ImportDateTimePropertyL(aParser, KVersitTokenDTSTART, dummyTime, relativeTime))

		{

		if ( ! ImportDateTimePropertyL(aParser, KVersitTokenDTEND, dummyTime, relativeTime))

			{

			if ( ! ImportDateTimePropertyL(aParser, KVersitTokenDUE, dummyTime, relativeTime))

				{

				// no time

				relativeTime = TVersitDateTime::EIsUTC;

				}

			}

		}

	if (iTzZone || relativeTime == TVersitDateTime::EIsUTC)

		{

		return TCalTime::EFixedUtc;

		}

	return TCalTime::EFloating;

	}

// Try and find out which Epoc Agenda entry type this belongs to.

// At the moment, relies on having an 'X-EPOCAGENDAENTRYTYPE' field, and defaults to a appointment

// type if this isn't present.

// Maybe some heuristics should be used to try and ascertain which entry type is most appropriate

// e.g. if the entry has a yearly repeat, then maybe it should be an anniversary type.

//

// A call to this function resets iVcalTokenTypeReminder flag (unless the vCal entry is actually a Reminder).

//

CCalEntry::TType CVCalToAgendaEntryConverter::GetEntryTypeL(CVersitParser& aParser)

	{

	// If the entry type is a Todo, return immediately

	if (aParser.EntityName()==KVersitVarTokenVTODO)

		{

		return CCalEntry::ETodo;

		}

	// get properties but don't take ownership of the elements of the array

	CArrayPtr<CParserProperty>* properties = aParser.PropertyL(KVCalToken8XDASHENTRYTYPE, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

	if (properties)

		{

		TPtrC type = static_cast<CParserPropertyValueHBufC*>((*properties)[0]->Value())->Value();

		delete properties;

		if (type == KVCalTokenTypeAPPT)

			{

			return CCalEntry::EAppt;

			}

		if (type == KVCalTokenTypeEVENT)

			{

			return CCalEntry::EEvent;

			}

		if (type == KVCalTokenTypeANNIV)

			{

			return CCalEntry::EAnniv;

			}

		if (type == KVCalTokenTypeTODO)

			{

			return CCalEntry::ETodo;

			}

		if (type == KVCalTokenTypeREMINDER)

			{

			return CCalEntry::EReminder;

			}

		}

	// return an appointment as default type

	return (CCalEntry::EAppt);

	}

TBool CVCalToAgendaEntryConverter::IsValidTime(const TTime& aTime)

	{

	if (aTime < TCalTime::MinTime() || aTime > TCalTime::MaxTime())

		{

		return EFalse;

		}

	return ETrue;

	}

// Import Recurrence Dates property

//

void CVCalToAgendaEntryConverter::ImportRDatePropertyL(CVersitParser& aParser, const TDesC8& aToken)

	{

	// get properties but don't take ownership of the elements of the array

	CArrayPtr<CParserProperty>* properties = aParser.PropertyL(aToken, TUid::Uid(KVersitPropertyMultiDateTimeUid), EFalse);

	if (properties)

		{

		CleanupStack::PushL(properties);

		CArrayPtr<TVersitDateTime>* rDates = static_cast<CParserPropertyValueMultiDateTime*>((*properties)[0]->Value())->Value();

		if (rDates)	

			{

			RArray<TCalTime>calrdates;

			CleanupClosePushL(calrdates);

			const TInt KSize = rDates->Count();

			for (TInt count = 0; count < KSize; ++count)