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

#include <vtzrules.h>

#include <ecom/implementationproxy.h>

#include <calrrule.h>

#include <calentry.h>

#include <caldataformat.h>

/**

@internalComponent

*/

template<class T> void CalCleanup<T>::PushResetAndDestroyL(T& aRef)

	{

	CleanupStack::PushL(TCleanupItem(ResetAndDestroy, &aRef));

	}

/**

@internalComponent

*/

template<class T> void CalCleanup<T>::PushResetL(T& aRef)

	{

	CleanupStack::PushL(TCleanupItem(Reset, &aRef));

	}

/**

@internalComponent

*/	

template <class T> void CalCleanup<T>::ResetAndDestroy(TAny* aPtr)

	{

	T* self = static_cast<T*>(aPtr);

	if (self)

		{

		self->ResetAndDestroy();

		}

	}

/**

@internalComponent

*/	

template <class T> void CalCleanup<T>::Reset(TAny* aPtr)

	{

	T self = static_cast<T>(aPtr);

	if (self)

		{

		self->Reset();

		}

	}

/** Global function for ease of use of CalCleanup template class

@internalComponent

*/

template<class T> void CleanupResetAndDestroyPushL(T& aRef)

	{

	CalCleanup<T>::PushResetAndDestroyL(aRef);

	}

/** Global function for ease of use of CalCleanup template class

@internalComponent

*/

template<class T> void CleanupResetPushL(T& aRef)

	{

	CalCleanup<T>::PushResetL(aRef);

	}

/**

 * Imports a <code>vCalendar</code> consisting of one or more

 * <code>vCalendar</code> entities.

 *

 * The <code>vCalendar</code> is read from the read stream specified and

 * its entities are converted into EPOC agenda entries and returned in

 * the array <code>aEntryArray</code>.

 *

 * @param     "RReadStream& aReadStream"

 *            The read stream which contains the

 *            <code>vCalendar</code>.

 * @param     "CArrayPtr<CCalEntry>* aEntryArray"

 *            On return, a list of the agenda entries which were

 *            imported from the <code>vCalendar</code>. The list

 *            contains the <code>vEvents</code> followed by the

 *            <code>vTodos</code>.

 */

void CAgnVCalConverter::ImportVCalL(TInt aFlags, RReadStream& aReadStream, RPointerArray<CCalEntry>& aEntryArray)

	{

	// Create a new converter object

	CVCalToAgendaEntryConverter* converter = new(ELeave)CVCalToAgendaEntryConverter();

	CleanupStack::PushL(converter);

	// Create a parser to internalize the entries

	CParserVCal* vCal = CParserVCal::NewL();

	CleanupStack::PushL(vCal);

	// Japan uses SHIFT-JIS as the default charset contrary to 

	// the vCalendar Specification which says that the default 

	// charset should be US-ASCII. 

	// In order to provide interoperability with this market

	// segment, allow a flag to override the default charset in versit.

	if(aFlags & KCalDataExchangeDefaultShiftJIS)

	    {

	    vCal->SetDefaultCharSet(Versit::EShiftJISCharSet);

	    vCal->SetFlags(CVersitParser::EUseDefaultCharSetForAllProperties);

	    }

	vCal->InternalizeL(aReadStream);

	// Set the time zone converter.  iTzConverter may be NULL if the optional

	// time zone conversion service is not available.  In this case all imported times 

	// will be exported as local time.

	if (iTzConnected)

		{

		converter->SetTzConverter(&iTzServer);

		}

	if (aFlags & KCalDataExchangeImportStatusAsVCalendar)

		{

		converter->SetImportVCalendarValues(ETrue);

		}

	else

		{

		converter->SetImportVCalendarValues(ETrue);

		}

	converter->SetTzRules(ImportTzRulesL(*vCal)); // converter takes ownership of rules collection.

	CArrayPtr<CVersitParser>* entities = vCal->ArrayOfEntities(EFalse); //doesn't take ownership

	if (entities)

		{

		TInt count = entities->Count();

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

			{

			CVersitParser& parser = *((*entities)[i]);			

			converter->ImportVCalL(parser, aEntryArray);

			} 

		}

	CleanupStack::PopAndDestroy(vCal);

	CleanupStack::PopAndDestroy(converter);

	}

/**

 * Exports a list of agenda entries as multiple vCalendar entities to the

 * write stream specified.

 *

 * The entries are exported either as vTodos, if they are to-dos,

 * otherwise as vEvents

 *

 * @param     "RWriteStream& aWriteStream"

 *            The stream to which the agenda entries should be

 *            externalised as vCalendar entities.

 * @param     "CArrayPtr<CCalEntry>* aEntryArray"

 *            Pointer to the array of agenda entries.

 * @param     "const Versit::TVersitCharSet aCharSet"

 *             The character encoding type

 */

void CAgnVCalConverter::ExportVCalL(RWriteStream& aWriteStream, const RPointerArray<CCalEntry>& aEntryArray, const Versit::TVersitCharSet aCharSet)

	{

	if(aEntryArray.Count()>0)

		{

		iCharSet = aCharSet;

		// Create a new converter object

		if(!iExportConverter)

			{

			iExportConverter = new(ELeave)CAgendaEntryToVCalConverter;

			}

		iEntryArray = const_cast<RPointerArray<CCalEntry>*>(&aEntryArray);

		// Set the time zone converter.  iTzConverter may be NULL if the optional

		// time zone conversion service is not available.  In this case all times will 

		// be exported as local time.

		if (iTzConnected)

			{

			iExportConverter->SetTzConverter(&iTzServer);

			}

		ExportEntryBySameTzL(aWriteStream);

		}

	}

void CAgnVCalConverter::ExportEntryBySameTzL(RWriteStream& aWriteStream)

	{//To export entries into a serveral vCal according to their tz rules

	if(!iSametzEntries)

		{

		iSametzEntries = new (ELeave) RPointerArray<CCalEntry>(4);

		}

	iSametzEntries->Reset();

	InitialiseSameTzEntryArrayL();

	//Find entries which belong to the first tz

	FindSameTzEntryL(*iSametzEntries);

	CParserVCal* vCal = NULL;

	//Expoet entries by grouping them into different tz rules 

	while(iSametzEntries->Count()>0)

		{//Pull entries with the same time zone in the same array and export them

		vCal = CParserVCal::NewL(); // takes ownership of entrylist

		CleanupStack::PushL(vCal);

		vCal->SetDefaultCharSet(iCharSet);

		ConvertEntryToVCalAndExportL(vCal, *iSametzEntries, aWriteStream);

		CleanupStack::PopAndDestroy(vCal);

		iSametzEntries->Reset();

		FindSameTzEntryL(*iSametzEntries);//this result in fill in iSametzEntries with same tz rule and remove the their indexes from iEntryIndexToExport

		}

	if(iEntryIndexToExport.Count()>0)

		{

		//Export the rest of entryies(those are entries without tz informations)

		ExportEntryWithoutTzRuleL(aWriteStream);

		}

	}

void CAgnVCalConverter::ExportEntryWithoutTzRuleL(RWriteStream& aWriteStream)

	{//This function only should be called when all entries in iEntryIndexToExport are either no-repeating or floating entry

	CParserVCal* vCal = CParserVCal::NewL(); // takes ownership of entrylist

	CleanupStack::PushL(vCal);

	vCal->SetDefaultCharSet(iCharSet);

	const TInt KCount = iEntryIndexToExport.Count();

	for (TInt ii = 0; ii < KCount; ++ii)

		{

		CCalEntry* entry = (*iEntryArray)[iEntryIndexToExport[ii]];

		if (entry)

			{

			TCalRRule rule;

			__ASSERT_DEBUG(!(entry->GetRRuleL(rule)) || entry->StartTimeL().TimeMode() == TCalTime::EFloating, User::Invariant());

			iExportConverter->ExportEntryL(entry, *vCal);

			}

		}

	vCal->ExternalizeL(aWriteStream);

	CleanupStack::PopAndDestroy(vCal);

	}

void CAgnVCalConverter::ConvertEntryToVCalAndExportL(CParserVCal* aVcal, const RPointerArray<CCalEntry>& aEntryArray, RWriteStream& aWriteStream)

	{

	iExportConverter->NextVCalendarL();

	TInt count = aEntryArray.Count();

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

		{

		CCalEntry* entry = aEntryArray[ii];

		if (entry)

			{

			iExportConverter->AddTimeZonePropertiesL(*aVcal, entry);

			iExportConverter->ExportEntryL(entry, *aVcal);

			}

		}

	aVcal->ExternalizeL(aWriteStream);

	}

void CAgnVCalConverter::ImportVCalAsyncL(TInt aFlags, RReadStream& aReadStream, 

		RPointerArray<CCalEntry>& aEntryArray, MCalDataExchangeCallBack& aObserver)

	{

	// Create a new converter object

	if(iAsyncState!=EIdle)

		{

		User::Leave(KErrInUse);

		}

	iImportConverter = new (ELeave) CVCalToAgendaEntryConverter();

	iVCalArray = new (ELeave) RPointerArray<CParserVCal>();

	// Read all the entries in the file. The parser will only read one.

	iTotalNumEntry = 0;

	TInt errcode = KErrNone;

	while (errcode != KErrEof)

   	 	{

 		// Create a parser to internalize the entries

		CParserVCal* vCal = CParserVCal::NewL();

		CleanupStack::PushL(vCal);

		// Japan uses SHIFT-JIS as the default charset contrary to 

		// the vCalendar Specification which says that the default 

		// charset should be US-ASCII. 

		// In order to provide interoperability with this market

		// segment, allow a flag to override the default charset in versit.

		if(aFlags & KCalDataExchangeDefaultShiftJIS)

		    {

		    vCal->SetDefaultCharSet(Versit::EShiftJISCharSet);

		    vCal->SetFlags(CVersitParser::EUseDefaultCharSetForAllProperties);

		    }

  	 	TRAP( errcode, vCal->InternalizeL(aReadStream) );

  	 	if (errcode ==KErrNone)

  	 		{

  	 		CArrayPtr<CVersitParser>* entities = vCal->ArrayOfEntities(EFalse); 

  	 		TInt numEntry = entities->Count();

	 		if(numEntry>0)

	 			{

	 			iVCalArray->AppendL(vCal);

	 			CleanupStack::Pop(vCal);

	 			iTotalNumEntry += numEntry;

	 			}

  	 		}

  	 	else if (errcode ==KErrEof)

  	 		{

  	 		CleanupStack::PopAndDestroy(vCal);

  	 		}

	  	else

	  	 	{

	  	 	User::LeaveIfError( errcode );

	  	 	}

     	}

	// Set the time zone converter.  iTzConverter may be NULL if the optional

	// time zone conversion service is not available.  In this case all imported times 

	// will be exported as local time.

	if (iTzConnected)

		{

		iImportConverter->SetTzConverter(&iTzServer);

		}

	iEntryArray = &aEntryArray;

	iTotalCounter = 0;

	iSameTzCounter = 0;

	iObserver = &aObserver;

	iAsyncState = EImporting;

	iMaxNumEntryInStep = iObserver->NumberOfEntriesToHandleAtOnce();

	if(iTotalNumEntry > 0)

		{

		CTzRules* tzRule = ImportTzRulesL(*((*iVCalArray)[0]));

		iImportConverter->SetTzRules(tzRule); // converter takes ownership of rules collection.

		}

	iImportExportActive->Start();

	}

void CAgnVCalConverter::FindSameTzEntryL(RPointerArray<CCalEntry>& aSameTzEntry)

	{

	//Fill in aSameTzEntry with those entries with the same tz rule in iEntryArray

	//Remove the index of the entry from iEntryIndexToExport

	//Note that the order of the entries being exported has to be maintained 

	CCalEntry* firstEntrywithTz = NULL;

	for (TInt ii = 0; ii < iEntryIndexToExport.Count();  ++ii)

		{

		TCalRRule repeatrule;//temp veraible

		CCalEntry* entry = (*iEntryArray)[iEntryIndexToExport[ii]];

		if(entry->GetRRuleL(repeatrule) && entry->StartTimeL().TimeMode() != TCalTime::EFloating)

			{//Otherwise time zone info is not needed to export

			if(firstEntrywithTz)

				{

				CTzRules* rules1 = entry->TzRulesL();

				CleanupStack::PushL(rules1);

				CTzRules* rules2 = firstEntrywithTz->TzRulesL();

				CleanupStack::PushL(rules2);

				if (rules1 && rules2 && rules1->IsEqualTo(*rules2))

					{

					//compare the time zone to see if it is the same as the "firstEntrywithTz"

					aSameTzEntry.AppendL(entry);

					iEntryIndexToExport.Remove(ii);

					--ii;

					}

				CleanupStack::PopAndDestroy(rules2);

				CleanupStack::PopAndDestroy(rules1);

				}

			else

				{

				firstEntrywithTz = entry;

				aSameTzEntry.AppendL(entry);

				iEntryIndexToExport.Remove(ii);

				--ii;

				}

			}

		}

	}

void CAgnVCalConverter::FindEntryWithoutTzRuleL(RPointerArray<CCalEntry>& aSameTzEntry)

	{

	// This functions should be only used for asynchronous exporting (use ExportEntryWithoutTzRuleL if it is for synchronous exporting)

	for (TInt ii = 0; ii< iEntryIndexToExport.Count();  ++ii)

		{//Pull those entries which do not need to export tz together (either non-repeating or floating entry)

		TCalRRule rule;

		CCalEntry* entry = (*iEntryArray)[iEntryIndexToExport[ii]];

		if(!entry->GetRRuleL(rule) || entry->StartTimeL().TimeMode() == TCalTime::EFloating)

			{

			aSameTzEntry.AppendL((*iEntryArray)[iEntryIndexToExport[ii]]);

			iEntryIndexToExport.Remove(ii);

			--ii;

			}

		}

	}

void CAgnVCalConverter::ExportVCalAsyncL(RWriteStream& aWriteStream, RPointerArray<CCalEntry>& aEntryArray, MCalDataExchangeCallBack& aObserver, const Versit::TVersitCharSet aCharSet)

	{

	if(iAsyncState!=EIdle)

		{

		User::Leave(KErrInUse);

		}

	iEntryArray = &aEntryArray;

	// Create a new converter object

	if(!iExportConverter)

		{

		iExportConverter = new(ELeave)CAgendaEntryToVCalConverter;

		}

	// Set the time zone converter.  iTzConverter may be NULL if the optional

	// time zone conversion service is not available.  In this case all times will 

	// be exported as local time.

	if (iTzConnected)

		{

		iExportConverter->SetTzConverter(&iTzServer);

		}

	if(!iSametzEntries)

		{

		iSametzEntries = new(ELeave) RPointerArray<CCalEntry>;

		}

	iCharSet = aCharSet;

	iSametzEntries->Reset();

	InitialiseSameTzEntryArrayL();

	iVCal = CParserVCal::NewL();

	iVCal->SetDefaultCharSet(iCharSet);

	iTotalNumEntry = iEntryArray->Count();

	iTotalCounter = 0;

	iSameTzCounter = 0;

	iObserver = &aObserver;

	iAsyncState = EExporting;

	iWriteStream = &aWriteStream;

	iMaxNumEntryInStep = iObserver->NumberOfEntriesToHandleAtOnce();

	FindSameTzEntryL(*iSametzEntries);

	if(iSametzEntries->Count()==0)

		{

		FindEntryWithoutTzRuleL(*iSametzEntries);

		__ASSERT_DEBUG(iEntryIndexToExport.Count()==0, User::Invariant());

		}

	iExportConverter->NextVCalendarL();

	iImportExportActive->Start();

	}

void CAgnVCalConverter::InitialiseSameTzEntryArrayL()

	{// Initialise the the array with the indexes of each element in iEntryArray

	iEntryIndexToExport.Reset();

	const TInt KCount = iEntryArray->Count();

	for (TInt ii = 0; ii<KCount; ++ii)

		{

		iEntryIndexToExport.AppendL(ii);

		}

	}

void CCalImportExportActive::RunL()

	{

	switch (iConverter.AsyncState())

		{

		case CAgnVCalConverter::EImporting:

			iConverter.NextImportStepL();

			break;

		case CAgnVCalConverter::EExporting:

			iConverter.NextExportStepL();

			break;

		default:

			case CAgnVCalConverter::EIdle:

			Panic(EAgnVersitPanicImportExportFailure);

			break;

		}

	}

CAgnVCalConverter::TState CAgnVCalConverter::AsyncState() const 

	{

	return iAsyncState;

	}

void CAgnVCalConverter::CheckCompletion()

	{

	if (iTotalCounter == iTotalNumEntry)

		{

		iObserver->Completed();

		CancelImportExport();

		}

	else

		{

		iObserver->Progress((iTotalCounter * 100) / iTotalNumEntry);

		iImportExportActive->Start();

		}

	}

void CAgnVCalConverter::NextImportStepL()

	{

	if(iTotalNumEntry>0)

		{

		CArrayPtr<CVersitParser>* entities = (*iVCalArray)[0]->ArrayOfEntities(EFalse); //doesn't take ownership

		TInt numSameTzEntry = entities->Count();

		TInt count = ((numSameTzEntry - iSameTzCounter) > iMaxNumEntryInStep)?iMaxNumEntryInStep:(numSameTzEntry - iSameTzCounter); 

		RPointerArray<CCalEntry> importedEntries;

		CleanupResetAndDestroyPushL(importedEntries);

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

			{

			CVersitParser& parser = *((*entities)[i + iSameTzCounter ]);

			iImportConverter->ImportVCalL(parser, importedEntries);

			for (TInt j = 0; j < importedEntries.Count(); j++)

				{

				iEntryArray->AppendL((importedEntries)[j]);

				}

			importedEntries.Reset();

			}

		CleanupStack::PopAndDestroy();//importedEntries

		iTotalCounter  += count;

		iSameTzCounter += count;

		if(iSameTzCounter == numSameTzEntry)

			{//Convert the next vCal into entries

			delete (*iVCalArray)[0];

			iVCalArray->Remove(0);

			if(iVCalArray->Count()>0)

				{

				CTzRules* tzRule = ImportTzRulesL(*((*iVCalArray)[0]));

				iImportConverter->SetTzRules(tzRule); // converter takes ownership of rules collection.

				iSameTzCounter = 0;