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

#include "agmattendee.h"

#include "agmcategory.h"

#include <calinterimapipanic.h>

#include "agmcontent.h"

#include "agmattachment.h"

#include "agmdate.h"

#include "agmrptdef.h"

#include "agmutil.h"

#include <calentry.h>

//#include "calentryimpl.h"

#include <e32math.h>

#include <asshddefs.h>

//---------------------------------- CAgnEntry ------------------------------------------

EXPORT_C CAgnEntry* CAgnEntry::NewL(CCalEntry::TType aType)

	{

	// allocate a CAgnEntry object, which invokes the CAgnSimpleEntry new operator, but passing no allocator

	// this makes the CAgnSimpleEntry new operator use the default new operator

	return new (ELeave, NULL) CAgnEntry(aType);;

	}

EXPORT_C CAgnEntry* CAgnEntry::NewL(RReadStream& aStream)

//Creates an entry and restores it from aStream

	{

	// type must be read first because NewL requires it

	TUint8 typeData = aStream.ReadUint8L();

	CCalEntry::TType type=CCalEntry::TType(typeData);

	__ASSERT_ALWAYS(type==CCalEntry::EAppt || type==CCalEntry::EEvent ||

					type==CCalEntry::EAnniv || type==CCalEntry::ETodo ||

	CAgnEntry* entry = CAgnEntry::NewL(type);

	CleanupStack::PushL(entry);

	entry->InternalizeL(aStream);

	CleanupStack::Pop();

	return entry;

	}

CAgnEntry::CAgnEntry(CCalEntry::TType aType) : CAgnSimpleEntry(aType)

	{

	iSummary = NULL;

	iSummaryStreamId = KNullStreamId;

	iDescription = NULL;

	iDescriptionStreamId = KNullStreamId;

	SetFlagOff(EAgnAlarmActionDeleted);

	iDTStampUtc = Time::NullTTime();

	iLatitude=KGEODefaultValue;

	iLongitude=KGEODefaultValue;

	}

void CAgnEntry::ConstructL(HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum)

	{

	iGsData = CGsParentData::NewL(aUid, aSeqNum, aMethod); // takes ownership of aUid

	}

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

	{

	iGsData = CGsChildData::NewL(aUid, aSeqNum, aMethod, aRecurrenceId, aRange); // takes ownership of aUid

	}

EXPORT_C CAgnEntry* CAgnEntry::NewL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum, const TAgnCalendarTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

	{

	CAgnEntry* entry = new (ELeave, NULL) CAgnEntry(aType);

	CleanupStack::PushL(entry);

	entry->ConstructL(aUid, aMethod, aSeqNum, aRecurrenceId, aRange);

	CleanupStack::Pop(entry);

	return entry;

	}

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

	{

	CAgnEntry* entry = new (ELeave, NULL) CAgnEntry(aType);

	CleanupStack::PushL(entry);

	entry->ConstructL(aUid, aMethod, aSeqNum);

	CleanupStack::Pop(entry);

	return entry;

	}

EXPORT_C CAgnEntry::~CAgnEntry()

/** The destructor frees all resources owned by the entry, prior to its destruction. 

@internalComponent

*/

	{

	if ( iAttendeeList )

		{

		iAttendeeList->ResetAndDestroy();

		delete iAttendeeList;

		}

	delete iMeetingOrganizer;

	delete iLocation;

	if ( iCategoryList )

		{

		iCategoryList->ResetAndDestroy();

		delete iCategoryList;

		}		

	if (iAttachments)

		{

		iAttachments->ResetAndDestroy();

		delete iAttachments;		

		}

	delete iDescription;

	delete iSummary;

	delete iAlarmSoundName;

	delete iAlarmAction;	

    delete iGsData;

	}

EXPORT_C const TDesC& CAgnEntry::Summary() const

/** Gets a pointer to the rich text object owned by the entry.

@internalComponent

@return Pointer to the rich text object. The caller does not take ownership. */

	{

	if ( iSummary )

		{

		return *iSummary;

		}

	return KNullDesC;

	}

EXPORT_C TBool CAgnEntry::CompareL(const CAgnEntry& aEntry) const

/** Compares another entry for equality with this one.

The entries' instance IDs and unique IDs are also compared.

@internalComponent

@param aEntry Pointer to an entry.

@param aCompareId This argument is used internally, for test purposes only. 

As it has a default value, it can be ignored by developers.

@return ETrue if aEntry is the same as this entry, EFalse if not. Note. Replication 

data is not included in the comparison, except for the replication status. 

*/

	{

	if ( ! (*this == aEntry) )

		{

		return EFalse;

		}

	if ( ReplicationStatus() != aEntry.ReplicationStatus() )

		{

		return EFalse;

		}

	if ( HasAlarm() )

		{

		if ( AlarmSoundName() != aEntry.AlarmSoundName() )

			{

			return EFalse;

			}

		CAgnContent* content1 = AlarmAction();

		CAgnContent* content2 = aEntry.AlarmAction();

		if ( content1 == NULL )

			{

			if ( content2 != NULL )

				{

				return EFalse;

				}

			}

		else

			{

			if ( content2 == NULL )

				{

				return EFalse;

				}

			if ( content1->Type() != content2->Type() )

				{

				return EFalse;

				}

			if ( content1->Content() != content2->Content() )

				{

				return EFalse;

				}

			if ( content1->MimeType() != content2->MimeType() )

				{

				return EFalse;

				}

			}

		}

	if ( BusyStatus() != aEntry.BusyStatus() )

		{

		return EFalse;

		}

	// Compare GEO values

	TReal entryLatitude;

	TReal entryLongitude;

	aEntry.GeoValue(entryLatitude,entryLongitude);

	if ( iLatitude != entryLatitude || entryLongitude != iLongitude )

		{

		return EFalse;

		}	

	// Compare the user integer.

	if (UserInt() != aEntry.UserInt())

	if ( DTStampUtcL() != aEntry.DTStampUtcL() )

		{

		return EFalse;

		}

	if ( Method() != aEntry.Method() )

		{

		return EFalse;

		}

	if ( SequenceNumber() != aEntry.SequenceNumber() )

		{

		return EFalse;

		}

	if ( RecurrenceId() != aEntry.RecurrenceId() )

		{

		return EFalse;

		}

	const TInt KNumOfCategories = CategoryCount();

	if ( aEntry.CategoryCount() != KNumOfCategories )

		{

		return EFalse;

		}

	const RPointerArray<CAgnCategory>* categoryList1 = iCategoryList;

	const RPointerArray<CAgnCategory>* categoryList2 = aEntry.iCategoryList;

	if (categoryList1 && categoryList2)

		{

		TBool categoryFound = EFalse;

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

			{

			categoryFound = EFalse;

			for ( TInt j = 0; ! categoryFound && j < KNumOfCategories; ++j )

				{

				if ( (*categoryList1)[i]->Category() == (*categoryList2)[j]->Category() )

					{

					if ( (*categoryList1)[i]->Category() == CCalCategory::ECalExtended )

						{

						if ( (*categoryList1)[i]->ExtendedCategoryName() == (*categoryList2)[j]->ExtendedCategoryName() )

							{

							categoryFound = ETrue;

							}

						}

					else

						{

						categoryFound = ETrue;

						}

					}

				}

			if ( !categoryFound )

				{

				return EFalse;

				}

			}

		}

	const TInt KNumOfAttendees = AttendeeCount();

	if ( KNumOfAttendees != aEntry.AttendeeCount() )

		{

		return EFalse;

		}

	if ( KNumOfAttendees > 0 && KNumOfAttendees == aEntry.AttendeeCount() )

		{

		const RPointerArray<CAgnAttendee>& KAttendeeList1 = *iAttendeeList;

		const RPointerArray<CAgnAttendee>& KAttendeeList2 = *aEntry.iAttendeeList;

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

			{

			const TPtrC& KAttendee1 = KAttendeeList1[i]->Address();

			TBool attendeeFound = EFalse;

			for ( TInt j = 0; !attendeeFound && j < KNumOfAttendees; ++j )

				{

				const TPtrC& KAttendee2 = KAttendeeList2[j]->Address();

				if ( KAttendee1.CompareF(KAttendee2) == 0 )

					{

					attendeeFound = ETrue;

					}

				}

			if ( !attendeeFound )

				{

				return EFalse;

				}

			}

		}

	const TInt KNumAttachments = AttachmentCount();

	if (KNumAttachments != aEntry.AttachmentCount())

		{

		return EFalse;

		}

	if (KNumAttachments > 0)

		{

		RArray<TBool> foundAttachmentAlready;

		CleanupClosePushL(foundAttachmentAlready);

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

			{

			foundAttachmentAlready.AppendL(EFalse);

			}

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

			{

			TBool attachmentFound = EFalse;

			for (TInt j = 0; j < KNumAttachments; ++j)

				{

				if (!foundAttachmentAlready[j] && Attachment(i).CompareL(aEntry.Attachment(j)))

					{

					foundAttachmentAlready[j] = ETrue;

					attachmentFound = ETrue;

					break;

					}

				}

			if (!attachmentFound)

				{

				CleanupStack::PopAndDestroy(); // foundAttachmentAlready.Close()

				return EFalse;

				}

			}

		CleanupStack::PopAndDestroy(); // foundAttachmentAlready.Close()

		}

	if ( PhoneOwner() == NULL )

		{

		if ( aEntry.PhoneOwner() != NULL )

			{

			return EFalse;

			}

		}

	else

		{

		// PhoneOwner() != NULL

		if ( aEntry.PhoneOwner() == NULL )

			{

			return EFalse;

			}

		else if ( PhoneOwner()->Address() != aEntry.PhoneOwner()->Address() )

			{

			return EFalse;

			}

		}

	if ( Summary() != aEntry.Summary() )

		{

		return EFalse;

		}

	if ( Description() != aEntry.Description() )

		{

		return EFalse;

		}

	if ( Location() != aEntry.Location() )

		{

		return EFalse;

		}

	return ETrue;

	}

EXPORT_C const TDesC& CAgnEntry::AlarmSoundName() const

/** Gets the name of the alarm sound as set by SetAlarmSoundName(). 

Returns NULL if the entry isn't alarmed.

@internalComponent

@return The name of the alarm sound. 

*/

	{

	if ( HasAlarm() && iAlarmSoundName )

		{

		return *iAlarmSoundName;

		}		

	return KNullDesC();

	}

EXPORT_C void CAgnEntry::SetAlarmSoundNameL(const TDesC& aAlarmSoundName)

/** Sets the name of the alarm sound.

Note: if the length of the new alarm sound name is greater than KMaxAlarmSoundName 

characters, it will be ignored.

@internalComponent

@param aAlarmSoundName The name of the alarm sound. 

*/

	{

	const TInt KLen = aAlarmSoundName.Length();

	if ( KLen > 0 && KLen <= KMaxAlarmSoundNameLength )

		{

		// delete and set always to NULL before AllocL because

		// that call could leave and the pointer be not NULL

		delete iAlarmSoundName;

		iAlarmSoundName = NULL;

		iAlarmSoundName = aAlarmSoundName.AllocL();

		}

	}

EXPORT_C void CAgnEntry::ClearAlarm()

/** Clear associated alarm

@internalComponent

*/

	{

	delete iAlarmSoundName;

	iAlarmSoundName = NULL;

	if ( iAlarmActionStreamId != KNullStreamId)

		{

		SetFlagOn(EAgnAlarmActionDeleted);

		}

    delete iAlarmAction;

    iAlarmAction = NULL;

	SetAlarmOffset(KAlarmNotSet);

	}

 void CAgnEntry::ExternalizeGsDataL(RWriteStream& aStream, TBool aToBuffer) const

	{

	aStream.WriteInt8L(GsDataType());

	if(aToBuffer)

		{

		iGsData->ExternalizeToBufferL(aStream);		

		}

	else

		{

		iGsData->ExternalizeL(aStream);	

		}

	}

EXPORT_C void CAgnEntry::PruneRDatesL(const TAgnCalendarTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

/**

Used when adding a repeating child to a parent entry.

Removes all sporadic dates either after or before the specified recurrence ID. 

@internalComponent

*/

	{

	__ASSERT_DEBUG(iGsData->GsDataType() == CGsData::EParent, Panic(EAgmErrNotParentEntry));

	__ASSERT_DEBUG(RptDef(), Panic(EAgmErrNotParentEntry));

	__ASSERT_DEBUG(aRange == CalCommon::EThisAndFuture || aRange == CalCommon::EThisAndPrior, Panic(EAgmErrInvalidRecurrenceRange));

	if (RptDef()->HasSporadicDates())

		{

		const RArray<TAgnCalendarTime>* KSporadicDates = RptDef()->SporadicDateList();

		for (TInt i = KSporadicDates->Count() - 1; i >= 0; --i)

			{

			const TAgnCalendarTime& KSporadicDate = (*KSporadicDates)[i];

			if ( (aRecurrenceId > KSporadicDate && aRange == CalCommon::EThisAndPrior ) ||

				 (aRecurrenceId < KSporadicDate && aRange == CalCommon::EThisAndFuture ) )

				{

				RptDef()->RemoveSporadicDate(KSporadicDate);

				}

			}

		}

	}

void CAgnEntry::InternalizeGsDataL(RReadStream& aStream, TBool aFromBuffer)

 	{

 	CGsData::TGsDataType dataType =  static_cast<CGsData::TGsDataType>(aStream.ReadInt8L());