/*

* Copyright (c) 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: Definition file for AgendaUtilPrivate class.

*

*/

// System includes

#include <hbextendedlocale.h>

#include <calsession.h>

#include <calinstance.h>

#include <CalenImporter>

#include <CalenInterimUtils2>

#include <calentry.h>

#include <calrrule.h>

#include <e32math.h>

#include <caluser.h>

#include <caldataexchange.h>

#include <caldataformat.h>

#include <f32file.h>

#include <s32file.h>

#include <asshddefs.h>

// User includes

#include <agendaentry.h>

#include "agendautil_p.h"

#include "agendaentry_p.h"

#include "CleanupResetAndDestroy.h"

// Constants

//recognition string for ical

_LIT8(KVersionICal,		"VERSION:2.0");

//recognition string for vcal

_LIT8(KVersionVCal,		"VERSION:1.0");

const TInt KReadDataAmount = 256;

const TInt KNoOfDaysInWeek = 7;

static const int startDateArray[2] = { 1900, 1};

static const int endDateArray[2] = { 2100, 1};

AgendaUtilPrivate::AgendaUtilPrivate(AgendaUtil* parent)

:q(parent)

{

	mEntryViewCreated = false;

	mInstanceViewCreated = false;

	mIsDeleting = false;

	mIsEntryViewBeingDeleted = false;

	mIsInstanceViewBeingDeleted = false;

	prepareSession();

}

bool AgendaUtilPrivate::prepareSession()

{

	if (iCalSession && mEntryViewCreated && mInstanceViewCreated)

		{

		// Everything is ready, nothing to be done

		return true;

		}

	// Create the cal session if not already there.

	if (!iCalSession)

		{

		TRAP(iError, iCalSession = CCalSession::NewL(););

		if (!iCalSession)

			{

			return false;

			}

		const TDesC& file = iCalSession->DefaultFileNameL();

		TRAPD(iError, iCalSession->OpenL(file));

		if (iError == KErrNotFound)

			{

			iCalSession->CreateCalFileL(file);

			iCalSession->OpenL(file);

			}

		else if (iError != KErrNone)

			{

			return false;

			}

		// Subscribe for notification on changes in the opened session (file).

		TCalTime startDate;

		TCalTime endDate;

		TDateTime startTime = TDateTime(

				startDateArray[0], static_cast<TMonth>(startDateArray[1]),

				0, 0, 0, 0, 0);

		TDateTime endTime = TDateTime(

				endDateArray[0], static_cast<TMonth>(endDateArray[1]),

				0, 0, 0, 0, 0);

		startDate.SetTimeUtcL(startTime);

		endDate.SetTimeUtcL(endTime);

		CalCommon::TCalTimeRange searchTimeRange(startDate, endDate);

		CCalChangeNotificationFilter* filter = 0;

		filter = CCalChangeNotificationFilter::NewL(

				MCalChangeCallBack2::EChangeEntryAll, true, searchTimeRange);

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

		// Cleanup.

		delete filter;

		}

	// First construct the CCalInstanceView if not already available.

	// The CCalEntryView is constructed in CompletedL. Instance view

	// is created before entry view since entry view is required only

	// when editing/saving any entry. So we will construct it later

	if (!iCalInstanceView) {

	    TRAP (iError, iCalInstanceView = CCalInstanceView::NewL(*iCalSession,

	                                                           *this);)

	}

	// All the requests have been made

	return true;

}

AgendaUtilPrivate::~AgendaUtilPrivate()

{

    if (iCalEntryView && !mIsEntryViewBeingDeleted) {

        mIsEntryViewBeingDeleted = true;

        delete iCalEntryView;

        iCalEntryView = NULL;

    }

    if (iCalInstanceView && !mIsInstanceViewBeingDeleted) {

        mIsInstanceViewBeingDeleted = true;

        delete iCalInstanceView;

        iCalInstanceView = NULL;

    }

	if (iCalSession) {

		iCalSession->StopChangeNotification();

	}

	delete iCalSession;

}

void AgendaUtilPrivate::Completed(TInt aError)

{

	iError = aError;

	if (mIsDeleting) {

		// If deletion was in progress, then it is completed now

		// emit the signal to the clients.

		mIsDeleting = false;

		emit q->entriesDeleted(iError);

	}

	if (KErrNone != iError) {

		// Something has gone wrong, return

		if (iCalEntryView && !mIsEntryViewBeingDeleted) {

            mIsEntryViewBeingDeleted = true;

            delete iCalEntryView;

            iCalEntryView = NULL;

            mIsEntryViewBeingDeleted = false;

		}

		if (iCalInstanceView && !mIsInstanceViewBeingDeleted) {

            mIsInstanceViewBeingDeleted = true;

            delete iCalInstanceView;

            iCalInstanceView = NULL;

            mIsInstanceViewBeingDeleted = false;

		}

		return;

	}

	if (iCalInstanceView && !mInstanceViewCreated) {

	    // Instance view is now created.

	    mInstanceViewCreated = true;

	    emit q->instanceViewCreationCompleted(iError);

	    // Start with the construction of entry view

		if (!iCalEntryView) {

		    TRAP (iError,

		          iCalEntryView = CCalEntryView::NewL(*iCalSession, *this);

		    );

		}

	} else if(iCalEntryView && !mEntryViewCreated) {

	    // Entry view is now constructed

		mEntryViewCreated = true;

		emit q->entryViewCreationCompleted(iError);

	}

}

void AgendaUtilPrivate::CalChangeNotification(

		RArray<TCalChangeEntry>& aChangeItems)

{

	QList<ulong> ids;

	for (int i = 0; i < aChangeItems.Count(); i++) {

		ids.append(aChangeItems[i].iEntryId);

	}

	emit q->entriesChanged(ids);

}

/*!

	To store the new entry or update the entry in the Calendar db.

	\param entry The entry to be added/updated.

	\param range The recurrence range of entry.

	\param instanceOriginalDateTime The start time of the original instance..

	\return ulong The local uid of the entry added/updated in the db.

*/

ulong AgendaUtilPrivate::store(

		AgendaEntry &entry, AgendaUtil::RecurrenceRange range,

		QDateTime &instanceOriginalDateTime)

{

	// Will be filled with the lUID of the new entry created.

	TCalLocalUid localUid = 0;

	// First check if the session to the calendar database is prepared or not.

	if (!mInstanceViewCreated) {

		// Something went wrong

		return localUid;

	}

	CCalEntry *calEntry = 0;

	TRAP(

			iError,

			// Get the global uid.

			CCalenInterimUtils2* calenInterimUtils2 = CCalenInterimUtils2::NewL();

			bool isChild = !(entry.recurrenceId().isNull());

			//Flag to decide whether entry is added or updated

			bool entryAdded = false;

			// if the entry id is zero means need to create a new entry

			if ((AgendaUtil::ThisAndAll == range) && (0 == entry.id())) {

				entryAdded = true;

				HBufC8* globalUid = calenInterimUtils2->GlobalUidL();

				CleanupStack::PushL(globalUid);

				calEntry

						= CCalEntry::NewL(

										  static_cast<CCalEntry::TType> (entry.type()),

										  globalUid,

										  static_cast<CCalEntry::TMethod> (entry.method()),

										  0);

				CleanupStack::Pop(globalUid);

			} else if (((AgendaUtil::ThisOnly == range) && isChild)

					|| ((AgendaUtil::ThisAndAll == range) && (entry.id() > 0))) {

				// Updating the entry/Exceptional entry

				calEntry = iCalEntryView->FetchL(entry.id());

				CleanupStack::PushL(calEntry);

				// Repeat rule 

				TCalRRule rrule;

				TBool isRepeating = calEntry->GetRRuleL( rrule );

				// If the repeat rule is cleared then Clear the Repeat rule from CCalEntry

				if ((AgendaUtil::ThisAndAll == range) 

						&& isRepeating && !(entry.isRepeating())) {

					calEntry->ClearRepeatingPropertiesL();

				}

				CleanupStack::Pop(calEntry);	

			} else {

				// Creating a exceptional entry

				if ((AgendaUtil::ThisOnly == range) && !isChild) {

					// Get the entry corresponding to the id.

					CCalEntry *parentEntry = iCalEntryView->FetchL(entry.id());

					CleanupStack::PushL(parentEntry);

					// We are creating an exception, hence get the global Uid

					HBufC8* guid = parentEntry->UidL().AllocLC();

					// create new (child) entry

					// Use original instance time for recurrenceID as this entry hasn't got one.

					TCalTime originalCalTime;

					TDateTime originalDateTime(instanceOriginalDateTime.date().year(),

								TMonth(instanceOriginalDateTime.date().month() - 1),

								instanceOriginalDateTime.date().day() -1,

								0,

								0,

								0,

								0);

					TTime originalDateTimeTTime(originalDateTime);

					// Use floating time for non-timed entries so that

					// the time will be same regardless of the timezone

					if(entry.isTimedEntry()) {

					    originalCalTime.SetTimeLocalL(originalDateTimeTTime);					    					    

					}else {

					    originalCalTime.SetTimeLocalFloatingL(originalDateTimeTTime);

					}

					// create the new child now

					calEntry = CCalEntry::NewL(parentEntry->EntryTypeL(), 

											   guid,

											   parentEntry->MethodL(),

											   parentEntry->SequenceNumberL(),

											   originalCalTime,

											   CalCommon::EThisOnly);

					// reset local UID and clear the repeat rule for exceptional entry

					calEntry->SetLocalUidL(TCalLocalUid(0));

					calEntry->ClearRepeatingPropertiesL();

					CleanupStack::Pop(guid);

					CleanupStack::PopAndDestroy(parentEntry);

					// clear repeat rule properties

					AgendaRepeatRule repeatrule;

					entry.setRepeatRule(repeatrule);

				}

			}

			// Converting agenda entry to CCalEntry to store it to database

			createCCalEntryFromAgendaEntry(entry, *calEntry);

			calenInterimUtils2->StoreL(*iCalEntryView, *calEntry, true);

			localUid = calEntry->LocalUidL();

			// Emit signal upon successful creation of entry.

			if (0 < localUid) {

				// if creating new entry then emit signal entryAdded else entryUpdated

				if (entryAdded) {

				emit q->entryAdded(localUid);

				} else {

					q->entryUpdated(localUid);

				}

			}

			delete calenInterimUtils2;

			delete calEntry;

	)

	return localUid;

}

/*!

	Clones the `entry' passed in the argument and saves it as type `type'.

	\param entry Entry which should be used for cloning.

	\param type The new type of the entry.

	\return ulong The local UID of the new entry.

	\sa deleteEntry()

 */

ulong AgendaUtilPrivate::cloneEntry(

		const AgendaEntry &entry, AgendaEntry::Type type)

{

	// First prepare the session with agenda server.

	if (!mInstanceViewCreated) {

		// Something went wrong.

		return 0;

	}

	if (entry.isNull()

			|| type == AgendaEntry::TypeUnknown) {

		return 0;

	}

	// Will be filled with the lUID of the new entry created.

	TCalLocalUid localUid = 0;

	int success = 0;

	CCalEntry *originalEntry = 0;

	HBufC8* globalUid = 0;

	// Get the stored entry first.

	TRAP(

			iError,

			originalEntry = iCalEntryView->FetchL(entry.id());

	)

	if (!originalEntry) {

		return 0;

	}

	// Now save the GUID of the saved entry.

	TRAP(

			iError,

			globalUid = originalEntry->UidL().AllocL();

	)

	delete originalEntry;

	// Now start cloning and create a new entry.

	if (AgendaEntry::TypeNote == type) {

		TRAP(

				iError,

				RPointerArray<CCalEntry> entryArray;

				CleanupClosePushL(entryArray);

				// Construct a CCalEntry object and start filling the details.

				CCalEntry* newEntry = 0;

				newEntry = CCalEntry::NewL(

						static_cast<CCalEntry::TType>(type),

						globalUid,

						static_cast<CCalEntry::TMethod>(entry.method()),

						0);

				// Add description.

				TPtrC description(reinterpret_cast<const TUint16*>(

						entry.description().utf16()));

				newEntry->SetDescriptionL(description);

				// Set the favourite property.

				newEntry->SetFavouriteL(entry.favourite());

				// Finally set the entry to the database using the entry view.

				entryArray.AppendL(newEntry);

				iCalEntryView->StoreL(entryArray, success);

				localUid = newEntry->LocalUidL();

				// Cleanup.

				CleanupStack::PopAndDestroy(&entryArray);

		)

	} else {

		TRAP(

				iError,

				RPointerArray<CCalEntry> entryArray;

				CleanupClosePushL(entryArray);

				// Construct a CCalEntry object and start filling the details.

				CCalEntry* newEntry = 0;

				newEntry = CCalEntry::NewL(

						static_cast<CCalEntry::TType>(type),

						globalUid,

						static_cast<CCalEntry::TMethod>(entry.method()),

						0);

				// Add the summary.

				if (!entry.summary().isNull()) {

					TPtrC summary(reinterpret_cast<const TUint16*>(

							entry.summary().utf16()));

					newEntry->SetSummaryL(summary);

				}

				// Set the entry Start/End Date and time.

				QDate date = entry.startTime().date();

				QTime time = entry.startTime().time();

				TDateTime startDateTime(

						date.year(), static_cast<TMonth>(date.month() - 1),

						date.day() - 1, time.hour(), time.minute(), 0, 0);

				TTime entryStartTime(startDateTime);

				TCalTime calStartTime;

				date = entry.endTime().date();

				time = entry.endTime().time();

				TDateTime endDateTime(

						date.year(), static_cast<TMonth>(date.month() - 1),

						date.day() - 1, time.hour(), time.minute(), 0, 0);

				TTime entryEndTime(endDateTime);

				TCalTime calEndTime;

				bool isNonFloating = false;

                // Use floating time for non-timed entries so that

                // the time will be same regardless of the timezone

				if(type == AgendaEntry::TypeAppoinment|| type == AgendaEntry::TypeReminder) {

				    calStartTime.SetTimeLocalL(entryStartTime); 

				    calEndTime.SetTimeLocalL(entryEndTime);

				    isNonFloating = true;

				}else {

				    calStartTime.SetTimeLocalFloatingL(entryStartTime);

				    calEndTime.SetTimeLocalFloatingL(entryEndTime); 

				    isNonFloating = false;

				}

				newEntry->SetStartAndEndTimeL(calStartTime, calEndTime);

				// Add attendees to the entry.

				addAttendeesToEntry(entry.d->m_attendees, *newEntry);

				// Add categories to the entry.

				addCategoriesToEntry(entry.d->m_categories, *newEntry);

				// Add description to the entry.

				TPtrC description(reinterpret_cast<const TUint16*>(

						entry.description().utf16()));

				newEntry->SetDescriptionL(description);

				// Set the favourite property.

				newEntry->SetFavouriteL(entry.favourite());

				// Add Alarm to the entry.

				AgendaAlarm alarm = entry.alarm();

				if (!alarm.isNull()) {

					setAlarmToEntry(alarm, *newEntry);

				}

				// Set the priority.

				int priority = entry.priority();

				if (entry.priority() != -1) {

					newEntry->SetPriorityL(priority);

				}

				// Set the location.

				if (!entry.location().isNull()) {

					TPtrC location(reinterpret_cast<const TUint16*>(

							entry.location().utf16()));

					newEntry->SetLocationL(location);

				}

				// Set the repeat type if applicable.

				if (AgendaRepeatRule::InvalidRule

						!= entry.repeatRule().type()) {