// Copyright (c) 2005-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 "calentryimpl.h"

#include "calclient.h"

#include "agsalarm.h"

#include "agmattachment.h"

#include "agmdate.h"

#include "agmentry.h"

#include "agmpanic.h"

#include "agmcategory.h"

#include "agmattendee.h"

#include "agmcontent.h"

#include <calalarm.h>

#include "calcategoryimpl.h"

#include <calcontent.h>

#include <calrrule.h>

#include <calsession.h>

#include "calsessionimpl.h"

#include "caluserimpl.h"

const TInt KAttendeeGranularity = 2;

const TInt KCategoryGranularity = 1;

const TInt KAttachmentGranularity = 1;

CCalEntryImpl::~CCalEntryImpl()

	{

	if(iSessionImpl)

		{

		iSessionImpl->DecrementReferenceCount();

		}

	if (iLiteEntry)

 		{

		iLiteEntry->DecrementRefCount();

 		}

	if(iCalAttachmentList)

		{

		iCalAttachmentList->ResetAndDestroy();

		delete iCalAttachmentList; 	

		}

	if(iCalAttendeeList)

		{

		iCalAttendeeList->ResetAndDestroy();

		delete iCalAttendeeList;

		}

	if(iCalCategoryList)

		{

		iCalCategoryList->ResetAndDestroy();

		delete iCalCategoryList;

		}

	delete iCalOrganizer;

	delete iFullEntry;

	}

CCalEntryImpl::CCalEntryImpl()

	{

	}

CCalEntryImpl::CCalEntryImpl(CAgnEntry& aEntry, CCalSessionImpl& aSessionImpl)

	: iFullEntry(&aEntry), iSessionImpl(&aSessionImpl)

	{

	iSessionImpl->IncrementReferenceCount();

	}

CCalEntryImpl::CCalEntryImpl(CCalLiteEntry& aEntry, CCalSessionImpl& aSessionImpl)

	: iLiteEntry(&aEntry), iSessionImpl(&aSessionImpl)

 	{

 	iSessionImpl->IncrementReferenceCount();

	iLiteEntry->IncrementRefCount();

 	}

void CCalEntryImpl::ClearSimpleEntry()

	{

	if (iSessionImpl && iLiteEntry)

		{

		iLiteEntry->DecrementRefCount();

		iLiteEntry = NULL;

		}

	}

CCalEntryImpl* CCalEntryImpl::NewL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum)

	{

	__ASSERT_ALWAYS(aUid && aUid->Length() > 0, User::Leave(KErrArgument));

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

	CleanupStack::PushL(self);

	self->ConstructL(aType, aUid, aMethod, aSeqNum); // takes ownership of aUid

	CleanupStack::Pop(self);

	return self;

	}

CCalEntryImpl* CCalEntryImpl::NewL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod,

			TUint aSeqNum, const TCalTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

	{

	__ASSERT_ALWAYS(aUid && aUid->Length() > 0, User::Leave(KErrArgument));

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

	CleanupStack::PushL(self);

	self->ConstructL(aType, aUid, aMethod, aSeqNum, CalUtils::TCalTimeToTAgnCalendarTimeL(aRecurrenceId), aRange);

	   // takes ownership of aUid

	CleanupStack::Pop(self);

	return self;

	}

CCalEntryImpl* CCalEntryImpl::NewL(CAgnEntry& aEntry, CCalSessionImpl& aSessionImpl)

	{

	CCalEntryImpl* self = new (ELeave) CCalEntryImpl(aEntry, aSessionImpl);

	return self;

	}

CCalEntryImpl* CCalEntryImpl::NewL(CCalLiteEntry& aEntry, CCalSessionImpl& aSessionImpl)

	{

	CCalEntryImpl* self = new (ELeave) CCalEntryImpl(aEntry, aSessionImpl);

	return self;

	}

void CCalEntryImpl::ConstructL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum, const TAgnCalendarTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

	{

	// Create appropriate CAgnEntry type child entry.

	iFullEntry = CAgnEntry::NewL(aType, aUid, aMethod, aSeqNum, aRecurrenceId, aRange); // takes ownership of aUid

	}

void CCalEntryImpl::ConstructL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum)

	{

	// Create appropriate CAgnEntry type parent entry.

	iFullEntry = CAgnEntry::NewL(aType, aUid, aMethod,aSeqNum);

	}

void CCalEntryImpl::LoadFullEntryL()

	{

	if (iLiteEntry)

		{

		// iFullEntry should be NULL at this point

		__ASSERT_DEBUG(iFullEntry == NULL, User::Leave(KErrCorrupt));

		// extract full CAgnEntry from TAgnLiteEntry and store it in iFullEntry

		TCalLocalUid id = iLiteEntry->LiteEntry().LocalUid();

		iFullEntry = iSessionImpl->Server().FetchEntryL(id, iSessionImpl->FileId());

		__ASSERT_ALWAYS(iFullEntry, User::Leave(KErrNotFound));

		iFullEntry->SetCollectionId(iLiteEntry->LiteEntry().CollectionId());

		ClearSimpleEntry();

		}

	}

// return the CAgnEntry associated with this entry, loading it from the server if necessary

CAgnEntry* CCalEntryImpl::GetFullEntryL()

	{

	LoadFullEntryL();

	return iFullEntry;

	}

void CCalEntryImpl::PopulateCategoryListL()

	{

	if (!iCalCategoryList)

		{

		LoadFullEntryL();

		iCalCategoryList = new (ELeave) RPointerArray<CCalCategory>(KCategoryGranularity);

		const TInt KCategoryCount = iFullEntry->CategoryCount();

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

			{

			CAgnCategory& agnCategory = iFullEntry->FetchCategory(i); // ownership not taken

			CCalCategoryImpl* impl = CCalCategoryImpl::NewL(&agnCategory); // doesn't take ownership of agnCategory

			CleanupStack::PushL(impl);

			CCalCategory* category = CCalCategory::NewL(impl); // takes ownership of impl

			CleanupStack::Pop(impl);

			CleanupStack::PushL(category);

			iCalCategoryList->AppendL(category); // takes ownership of category

			CleanupStack::Pop(category);

			}

		}

	}

void CCalEntryImpl::PopulateAttendeeListL()

	{

	if(!iCalAttendeeList)

		{

		LoadFullEntryL();

		iCalAttendeeList = new(ELeave) RPointerArray<CCalAttendee>(KAttendeeGranularity);

		const TInt KAttendeeCount = iFullEntry->AttendeeCount();

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

			{

			CAgnAttendee& agnAttendee = iFullEntry->FetchAttendee(i);

			CCalUserImpl* impl = CCalUserImpl::NewL(&agnAttendee);	// doesn't take ownership of agnAttendee

			CleanupStack::PushL(impl);

			CCalAttendee* calAttendee = CCalAttendee::NewL(impl);	// takes ownership of impl

			CleanupStack::Pop(impl);

			CleanupStack::PushL(calAttendee);

			iCalAttendeeList->AppendL(calAttendee);

			CleanupStack::Pop(calAttendee);

			}

		}

	}

void CCalEntryImpl::AddAttendeeL(CCalAttendee* aAttendee)

	{

    if (!aAttendee)

        {

        User::Leave( KErrArgument );

        }

	CleanupStack::PushL(aAttendee);

	__ASSERT_ALWAYS(aAttendee != NULL, User::Leave(KErrArgument));

	PopulateAttendeeListL();

	CCalUserImpl* userImpl = aAttendee->Impl();

	CAgnAttendee* attendee = userImpl->Attendee();

	// add attendee to CAgnEntry (no longer owned by CCalAttendee)

	userImpl->SetOwnsCAgnAttendee(EFalse);		

	iFullEntry->AddAttendeeL(attendee);		

	// store attendee in attendee array too

	iCalAttendeeList->AppendL(aAttendee);

	CleanupStack::Pop(aAttendee);

	}

RPointerArray<CCalAttendee>& CCalEntryImpl::AttendeesL()

	{

	PopulateAttendeeListL();

	return *iCalAttendeeList;

	}

void CCalEntryImpl::DeleteAttendeeL(TInt aIndex)

	{

	LoadFullEntryL();

	if(iCalAttendeeList)

		{

		if (aIndex < 0 || aIndex >= iCalAttendeeList->Count())

			{

			User::Leave(KErrArgument);

			}

		delete (*iCalAttendeeList)[aIndex];

		iCalAttendeeList->Remove(aIndex);

		}

	iFullEntry->DeleteAttendee(aIndex);

	}

void CCalEntryImpl::SetOrganizerL(CCalUser* aUser)

	{

	CleanupStack::PushL(aUser);

	__ASSERT_ALWAYS(aUser != NULL, User::Leave(KErrArgument));

	LoadFullEntryL();

	aUser->Impl()->SetOwnsCAgnAttendee(EFalse);

	iFullEntry->SetOrganizerL(aUser->Impl()->Attendee());	//	takes ownership of user immediately

	delete iCalOrganizer;

	iCalOrganizer = aUser;

	CleanupStack::Pop(aUser);

	}

void CCalEntryImpl::SetPhoneOwnerL(const CCalUser* aOwner)

	{

	__ASSERT_ALWAYS(aOwner != NULL, User::Leave(KErrArgument));

	LoadFullEntryL();

	CCalUserImpl* userImpl = aOwner->Impl();

	iFullEntry->SetPhoneOwnerL(userImpl->Attendee());

	}

CCalUser* CCalEntryImpl::PhoneOwnerL()

	{

	LoadFullEntryL();

	CAgnAttendee* agnPhoneOwner = iFullEntry->PhoneOwner();

	if(agnPhoneOwner)

		{	

		//check to see if phone owner is the organizer

		if(OrganizerL())

			{

			if(agnPhoneOwner == iCalOrganizer->Impl()->Attendee())

				{

				return iCalOrganizer;

				}

			}

		PopulateAttendeeListL();

		// see if the phone owner is one of the other attendees

		const TInt KAttendeeCount = iCalAttendeeList->Count();

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

			{

			CCalAttendee* calAttendee = (*iCalAttendeeList)[i];

			if(agnPhoneOwner == calAttendee->Impl()->Attendee())

				{

				return calAttendee;

				}

			}

		}

	return NULL;

	}

CCalUser* CCalEntryImpl::OrganizerL()

	{

	LoadFullEntryL();

	if( ! iCalOrganizer)

		{

		CAgnAttendee* organizer = iFullEntry->Organizer();

		if(organizer)

			{

			CCalUserImpl* impl = CCalUserImpl::NewL(organizer);

			CleanupStack::PushL(impl);

			impl->SetOwnsCAgnAttendee(EFalse);

			iCalOrganizer = CCalUser::NewL(impl);

			CleanupStack::Pop(impl);

			}

		}

	return iCalOrganizer;

	}

CTzRules* CCalEntryImpl::GetTzRulesL()

	{

	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

	if (rptDef == NULL)

		{

		return NULL;

		}

	return rptDef->CloneTzRulesL();

	}

void CCalEntryImpl::SetTzRulesL(const CTzRules& aTzRules)

	{

	LoadFullEntryL();

	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

		{

		User::Leave(KErrArgument);

		}

	CAgnRptDef* rptDef = SimpleEntry()->RptDef(); // doesn't take ownership

	if (!rptDef)

		{

		User::Leave(KErrNotFound);

		}

	rptDef->SetTimeZoneL(aTzRules); // rptDef doesn't take ownership of aTzRules

	}

void CCalEntryImpl::SetTzRulesL()

	{

	LoadFullEntryL();

	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

		{

		User::Leave(KErrArgument);

		}

	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

	if (rptDef == NULL)

		{

		User::Leave(KErrNotFound);

		}

	rptDef->SetTimeZoneL();

	}

void CCalEntryImpl::SetRDatesL(const RArray<TCalTime>& aRDates)

	{

	LoadFullEntryL();

	SetDatesL(ETrue, aRDates);

	}

void CCalEntryImpl::SetExceptionDatesL(const RArray<TCalTime>& aExDates)

	{

	LoadFullEntryL();

	if (iFullEntry->RptDef() == NULL)

		{

		User::Leave(KErrNotFound);

		}

	SetDatesL(EFalse, aExDates);

	}

//if aDateType is ETrue, add dates to sporadic date list

//if aDateType is EFalse, add dates to exception list

void CCalEntryImpl::SetDatesL(TBool aDateType, const RArray<TCalTime>& aDates)

	{

	const TCalTime::TTimeMode KEntryTimeMode = static_cast<TCalTime::TTimeMode>(TimeMode());

	const TInt KDateCount = aDates.Count();

	TInt i = 0;

	for (i = 0; i < KDateCount; i++)

		{

		if (aDates[i].TimeMode() != KEntryTimeMode)

			{

			User::Leave(KErrArgument);

			}

		}

	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

	TBool entryHasNoRptDef(rptDef == NULL);

	if (entryHasNoRptDef)

		{

		rptDef = CAgnRptDef::NewL(*SimpleEntry());

		CleanupStack::PushL(rptDef);

		}

	else

		{

		if (aDateType)

			{

			rptDef->RemoveAllSporadicDates();

			}

		else

			{

			rptDef->RemoveAllExceptions();

			}

		}

	// store the dates

	for (i = 0; i < KDateCount; ++i)

		{

		TAgnCalendarTime agnTime = CalUtils::TCalTimeToTAgnCalendarTimeL(aDates[i]);

		if (aDateType)

			{

			rptDef->AddSporadicDateL(agnTime);

			}

		else

			{

			rptDef->AddExceptionL(agnTime);

			}

		}

	// if the rptDef didn't exist in the entry already, add it

	if (entryHasNoRptDef)

		{

		iFullEntry->SetRptDefL(*rptDef); // makes a copy of rptDef

		CleanupStack::PopAndDestroy(rptDef);

		}

	}

void CCalEntryImpl::GetRDatesL(RArray<TCalTime>& aRDates)

	{

	aRDates.Reset();

	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();

	if (KRptDef)

		{

		FetchDatesL(KRptDef->SporadicDateList(), aRDates);

		}

	}

void CCalEntryImpl::GetExceptionDatesL(RArray<TCalTime>& aExDates)

	{

	aExDates.Reset();

	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();

	if (KRptDef)

		{

		FetchDatesL(KRptDef->Exceptions(), aExDates);

		}

	}

void CCalEntryImpl::FetchDatesL(const RArray<TAgnCalendarTime>* aDateList, RArray<TCalTime>& aRDates)

	{

	// aDateList may be NULL

	if (aDateList)

		{

		const TInt KDateCount = aDateList->Count();

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

			{

			TCalTime calTime = CalUtils::TAgnCalendarTimeToTCalTimeL((*aDateList)[i]);

			aRDates.AppendL(calTime);

			}

		}

	}

CCalEntry::TMethod CCalEntryImpl::MethodL()

	{

	LoadFullEntryL();

	return iFullEntry->Method();

	}

TCalTime CCalEntryImpl::RecurrenceIdL()

	{

	// If this entry has been committed to store, the Rec-Id can be retrieved from the

	// CAgnEntryModel by passing the appropraite CAgnEntry.

	// Else try to retrieve it from CAgnEntry's temporary GS data.

	LoadFullEntryL();

	return CalUtils::TAgnCalendarTimeToTCalTimeL(iFullEntry->RecurrenceId());

	}

CalCommon::TRecurrenceRange CCalEntryImpl::RecurrenceRangeL()

   	{

   	LoadFullEntryL();

	return iFullEntry->RecurrenceRange();

   	}