/*

 * Copyright (c) 2010 Sun Microsystems, Inc. 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 Contributor:

 * Maximilian Odendahl

 *

 * Contributors:

 * 

 * Description:  main Caldav class, all magic happens here 

 *				one engine for each configured Caldav calendar

 */

#include "caldavengine.h"

#include <f32file.h> 

#include <S32FILE.H>

#include <S32MEM.H> 

#include <avkon.rsg>

#include <UTF.H>

#include <agnexportobserver.h>

#include <calsession.h>

#include <caliterator.h>

#include <calentry.h>

#include <calentryview.h>

#include <caltime.h>

#include <calalarm.h>

#include <calcategory.h>

#include <caluser.h>

#include <calrrule.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caleninterimutils2.h> 

#include <calenexporter.h>

#include <calenimporter.h>

#include <calcalendarinfo.h>

#include "calenglobaldata.h"

#include <xmlengdocument.h>

#include <xmlengnode.h>

#include <xmlengelement.h>

#include <xmlengnodelist.h>

#include <xmlengtext.h>

#include "httpclient.h"

#include <e32math.h>	// divmod

#define MULTIGETSPLIT 			100

#define ARRAYEXPAND				4

#define	URLMAX					500

#define EXPANDSIZE_SMALL		512

#define EXPANDSIZE_BIG			1024

_LIT(KFormatString,"\"%F%Y%M%DT000000Z\"");

/**

 * SyncTickL

 * timer for basic sync interval

 */

TInt SyncTickL(TAny *aObject)

	{

	CCalDavEngine* engine = ((CCalDavEngine*) aObject);

	CPeriodic* timer = engine->Timer();

	if (engine && timer)

		{

		timer->Cancel();

		TRAP_IGNORE(engine->SyncL());

		TInt ticktime = engine->SyncInterval().Int() == 0 ? 1

				: engine->SyncInterval().Int();

		const TUint64 tickInterval = 1000000 * 60 * ticktime;

		timer->Start(tickInterval, tickInterval, TCallBack(SyncTickL, engine));

		}

	return 0;

	}

#ifdef _DEBUG

void ExportToFileNameL(const TDesC8& aDes, const TDesC &aFilename)

	{

	RFs fsSession;

	User::LeaveIfError(fsSession.Connect());

	CleanupClosePushL(fsSession);

	TInt err = fsSession.MkDirAll(aFilename);

	RFile file;

	User::LeaveIfError(file.Replace(fsSession, aFilename, EFileWrite));

	CleanupClosePushL(file);

	RFileWriteStream writeStream2;

	writeStream2.Attach(file);

	CleanupClosePushL(writeStream2);

	writeStream2 << aDes;

	writeStream2.CommitL();

	CleanupStack::PopAndDestroy(&writeStream2);

	CleanupStack::PopAndDestroy(&file);

	CleanupStack::PopAndDestroy(&fsSession);

	}

void ExportToFileL(CCalEntry* aEntry, CCalenExporter *iCalExporter)

	{

	if (aEntry)

		{

		_LIT(KFileName, "C:\\logs\\caldav\\testing_export.txt");

		RFs fsSession;

		User::LeaveIfError(fsSession.Connect());

		CleanupClosePushL(fsSession);

		TInt err = fsSession.MkDirAll(KFileName);

		RFile file;

		User::LeaveIfError(file.Replace(fsSession, KFileName, EFileWrite));

		CleanupClosePushL(file);

		RFileWriteStream writeStream2;

		writeStream2.Attach(file);

		CleanupClosePushL(writeStream2);

		iCalExporter->ExportICalL(*aEntry, writeStream2);

		writeStream2.CommitL();

		CleanupStack::PopAndDestroy(&writeStream2);

		CleanupStack::PopAndDestroy(&file);

		CleanupStack::PopAndDestroy(&fsSession);

		}

	}

#endif

/**

 * SearchL

 * search inside xml tree for a specific node

 */

void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

		const TDesC8 &aNamespace, TXmlEngNode & aReturnNode)

	{

	RXmlEngNodeList<TXmlEngNode> List;

	aTopNode.GetChildNodes(List);

	while (List.HasNext() && aReturnNode.IsNull())

		{

		TXmlEngNode Node = List.Next();

		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

		if (Type == TXmlEngNode::EElement)

			{

			//todo: compare namespace ?

			if (Node.Name() == aName)

				{

				aReturnNode = Node.CopyL();

				return;

				}

			else

				{

				SearchL(Node, aName, aNamespace, aReturnNode);

				if (!aReturnNode.IsNull())

					return;

				}

			}

		}

	}

/**

 * SearchL

 * search inside xml tree for a specific node

 */

void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

		const TDesC8 &aNamespace, RBuf8 &aBuf)

	{

	RXmlEngNodeList<TXmlEngNode> List;

	aTopNode.GetChildNodes(List);

	while (List.HasNext())

		{

		TXmlEngNode Node = List.Next();

		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

		if (Type == TXmlEngNode::EElement)

			{

			//todo: compare namespace ?

			if (Node.Name() == aName)

				{

				if (Node.IsSimpleTextContents())

					aBuf.Create(Node.Value());

				else

					Node.WholeTextContentsCopyL(aBuf);

				return;

				}

			else

				{

				SearchL(Node, aName, aNamespace, aBuf);

				if (aBuf.Length())

					return;

				}

			}

		}

	}

/**

 * SearchL

 * search inside xml tree for a specific node

 */

TPtrC8 SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

		const TDesC8 &aNamespace)

	{

	RXmlEngNodeList<TXmlEngNode> List;

	aTopNode.GetChildNodes(List);

	while (List.HasNext())

		{

		TXmlEngNode Node = List.Next();

		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

		if (Type == TXmlEngNode::EElement)

			{

			//todo: compare namespace ?

			if (Node.Name() == aName)

				return Node.Value();

			else

				{

				TPtrC8 Return = SearchL(Node, aName, aNamespace);

				if (Return != KNullDesC8)

					return Return;

				}

			}

		}

	return KNullDesC8();

	}

/**

 * GetBoolFromPropertiesL

 * get a boolean value from CCalCalendarInfo

 */

TBool GetBoolFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)

	{

	TBool boolean;

	TPckgC<TBool> pckgboolean(boolean);

	pckgboolean.Set(info->PropertyValueL(aKey));

	return pckgboolean();

	}

/**

 * GetTimeFromPropertiesL

 * get a time value from CCalCalendarInfo

 */

TCalTime GetTimeFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)

	{

	TCalTime time;

	TPckgC<TCalTime> pckgtime(time);

	pckgtime.Set(info->PropertyValueL(aKey));

	return pckgtime();

	}

/**

 * PropertyExists

 * finds a property from an array

 */

TBool PropertyExists(CDesC8Array* aArray, const TDesC8 &aKey)

	{

	TInt pos = 0;

	return aArray->Find(aKey, pos, ECmpNormal) == KErrNone;

	}

/**

 * CCalDavEngine::SetCalendarInfoL

 * set key and value pair at calendar session info

 */

void CCalDavEngine::SetCalendarInfoL(const TDesC8 &aKey, const TDesC8 &aValue)

	{

	TBool createdelete = !iCalSession;

	if (createdelete)

		{

		iCalSession = CCalSession::NewL();

		TRAP_IGNORE(iCalSession->OpenL(*iCalendar));

		}

	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();

	CleanupStack::PushL(calendarInfo);

	TPckgC<TBool> enabled(iEnabled);

	calendarInfo->SetPropertyL(KCaldavEnabled, enabled);

	if (aValue != KNullDesC8)

		calendarInfo->SetPropertyL(aKey, aValue);

	iCalSession->SetCalendarInfoL(*calendarInfo);

	CleanupStack::PopAndDestroy(calendarInfo);

	if (createdelete)

		{

		delete iCalSession;

		iCalSession = NULL;

		}

	}

/**

 * CCalDavEngine::CCalDavEngine

 * default constructor

 */

CCalDavEngine::CCalDavEngine() :

	iCalSession(0), iCalIter(0), iCalEntryView(0), iCalExporter(0),

			iCalImporter(0), iCalIntermimUtils2(0), iCalendar(0), iUrl(0),

			iBaseUrl(0), iHome(0), iHttp(0), iSynctoken(0), iCTag(0),

			iSyncInterval(DEFAULT_SYNC_MINUTES), iPastDays(DEFAULT_PAST_DAYS),

			iImmediateSync(DEFAULT_IMMEDIATE_SYNC), iKeepServerEntry(

					DEFAULT_KEEP_SERVER_ENTRY), iEnabled(EFalse), iTimer(0)

	{

	}

/**

 * CCalDavEngine::~CCalDavEngine

 * default destructor

 */

CCalDavEngine::~CCalDavEngine()

	{

	iLocalUidArray.Close();

	iGlobalUidArray.Close();

	iDeletedEntries.Close();

	iDomParser.Close();

	iDomImpl.Close();

	if (iCalendar)

		delete iCalendar;

	if (iUrl)

		delete iUrl;

	if (iBaseUrl)

		delete iBaseUrl;

	if (iHttp)

		delete iHttp;

	DeleteCalObjects();

	if (iCalIntermimUtils2)

		delete iCalIntermimUtils2;

	if (iSynctoken)

		delete iSynctoken;

	if (iCTag)

		delete iCTag;

	if (iHome)

		delete iHome;

	if (iTimer)

		delete iTimer;

	}

/**

 * CCalDavEngine::NewLC

 * first phase construction

 */

CCalDavEngine* CCalDavEngine::NewLC(const TDesC& aCalendar)

	{

	CCalDavEngine* self = new (ELeave) CCalDavEngine();

	CleanupStack::PushL(self);

	self->ConstructL(aCalendar);

	return self;

	}

/**

 * CCalDavEngine::NewL

 * first phase construction

 */

CCalDavEngine* CCalDavEngine::NewL(const TDesC& aCalendar)

	{

	CCalDavEngine* self = CCalDavEngine::NewLC(aCalendar);

	CleanupStack::Pop(self); // self;

	return self;

	}

/**

 * CCalDavEngine::

 * second phase construction

 */

void CCalDavEngine::ConstructL(const TDesC& aCalendar)

	{

	iManualSync = EFalse;

	iFirstInit = ETrue;

	iCalendar = aCalendar.AllocL();

	iHttp = CHttpClient::NewL();

	iDomImpl.OpenL();

	TInt err = iDomParser.Open(iDomImpl);

	if (KErrNone != err)

		User::Leave(err);

	iTimer = CPeriodic::NewL(EPriorityNormal);

	iCalIntermimUtils2 = CCalenInterimUtils2::NewL();

	iCalSession = CCalSession::NewL();

	TRAP_IGNORE(iCalSession->OpenL(aCalendar));

	CalendarInfoL();

	// we can't close the file, so delete it completly

	delete iCalSession;

	iCalSession = NULL;

	}

/**

 * CCalDavEngine::Progress

 * Progress callback

 */

void CCalDavEngine::Progress(TInt /*aPercentageCompleted*/)

	{

	}

/**

 * CCalDavEngine::RegisterL

 * register all neccessary notification callback

 */

void CCalDavEngine::RegisterL()

	{

	TDateTime Start;

	TDateTime End;

	End.SetYear(2200);

	TCalTime StartCal;

	TCalTime EndCal;

	StartCal.SetTimeLocalL(Start);

	EndCal.SetTimeLocalL(End);

	CalCommon::TCalTimeRange Range(StartCal, EndCal);

	CCalChangeNotificationFilter *Filter = CCalChangeNotificationFilter::NewL(

			MCalChangeCallBack2::EChangeEntryAll, true, Range);

	iCalSession->StartChangeNotification(*this, *Filter);

	iCalSession->StartFileChangeNotificationL(*this);

	delete Filter;

	}

/**

 * CCalDavEngine::CalendarInfoL

 * load all properties from CalendarInfo

 */

void CCalDavEngine::CalendarInfoL()

	{

	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();

	if (calendarInfo->IsValid())

		{

		CleanupStack::PushL(calendarInfo);

		CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();

		CleanupStack::PushL(propertyKeys);

		TInt pos = 0;

		if (propertyKeys->Find(KCaldavEnabled, pos, ECmpNormal) == KErrNone)

			{

			iEnabled = GetBoolFromPropertiesL(calendarInfo, KCaldavEnabled);

			if (PropertyExists(propertyKeys, KCaldavFirstInit))

				iFirstInit = GetBoolFromPropertiesL(calendarInfo,

						KCaldavFirstInit);

			if (PropertyExists(propertyKeys, KCaldavSynctoken))

				iSynctoken

						= calendarInfo->PropertyValueL(KCaldavSynctoken).AllocL();

			if (PropertyExists(propertyKeys, KCaldavCtag))

				iCTag = calendarInfo->PropertyValueL(KCaldavCtag).AllocL();

			if (PropertyExists(propertyKeys, KCaldavManualSync))

				iManualSync = GetBoolFromPropertiesL(calendarInfo,

						KCaldavManualSync);

			if (PropertyExists(propertyKeys, KCaldavTime))

				iLastSyncTime = GetTimeFromPropertiesL(calendarInfo,

						KCaldavTime);

			if (PropertyExists(propertyKeys, KCaldavUrl))

				iUrl = calendarInfo->PropertyValueL(KCaldavUrl).AllocL();

			if (PropertyExists(propertyKeys, KCaldavUser))

				iHttp->SetUserL(calendarInfo->PropertyValueL(KCaldavUser));

			if (PropertyExists(propertyKeys, KCaldavPassword))

				iHttp->SetPasswordL(calendarInfo->PropertyValueL(

						KCaldavPassword));

			if (PropertyExists(propertyKeys, KCaldavKeepServer))

				iKeepServerEntry = GetBoolFromPropertiesL(calendarInfo,

						KCaldavKeepServer);

			if (PropertyExists(propertyKeys, KCaldavImmediateSync))

				iImmediateSync = GetBoolFromPropertiesL(calendarInfo,

						KCaldavImmediateSync);

			if (PropertyExists(propertyKeys, KCaldavPastDays))

				{

				TPckgC<TTimeIntervalDays> pastdays(iPastDays);

				pastdays.Set(calendarInfo->PropertyValueL(KCaldavPastDays));

				iPastDays = pastdays();

				}

			if (PropertyExists(propertyKeys, KCaldavSyncInterval))

				{

				TPckgC<TTimeIntervalMinutes> syncinterval(iSyncInterval);

				syncinterval.Set(calendarInfo->PropertyValueL(

						KCaldavSyncInterval));

				iSyncInterval = syncinterval();

				}

			// access point	    

			}

		CleanupStack::PopAndDestroy(propertyKeys);

		CleanupStack::Pop(calendarInfo);

		}

	delete calendarInfo;

	}

/**

 * CCalDavEngine::InitL

 * check for correct url

 * load most Caldav url properties

 * do inital sync

 */

TInt CCalDavEngine::InitL()

	{

	// this is only needed to find a GlobalUID from a LocalUID, used after an event was deleted

	// also used now for uploading of local events when only GlobalUID is know 

	LocalLoopL(ELoopActionFillArray);

	if (iFirstInit)

		{

		TInt err = GetCalendarUrlsL(NULL);

		if (err == KErrArgument)

			return KErrArgument;

		GetOptionsL();

		SetLastSyncTimeL();

		TBool success;

		// get all server items

		if (iOptions.sync_collection)

			success = WebDavSyncL();

		else

			success = ListL() == KErrNone;

		if (!success)

			return KErrGeneral;

		// upload all local entries of this calendar to server

		LocalLoopL(ELoopActionUpload);

		if (iOptions.sync_collection)

			SetSyncTokenL(GetSyncTokenL());

		else

			SetCTagL(GetCTagL());

		iFirstInit = EFalse;

		iEnabled = ETrue;

		TPckgC<TBool> firstInit(iFirstInit);

		SetCalendarInfoL(KCaldavFirstInit, firstInit); // this will set iEnabled as well

		}

	else

		{