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

#include "agsalarm.h"

#include "agsasyncdelete.h"

#include "agsattachmentindex.h"

#include "agscategoryindex.h"

#include "agscategorylist.h"

#include "agsentrymanager.h"

#include "agmentry.h"

#include "agsextractor.h"

#include "agsfileconverter.h"

#include "agsiterator.h"

#include "agsstreamidset.h"

#include "agssort.h"

#include "agmutil.h"

#include "agmattendee.h"

#include "agmcategory.h"

#include "agssortinstance.h"

#include "agsindex.h"

#include "agmcontent.h"

#include "agsfilemanager.h"

#include "agsmain.h"

#include "agssess.h"

#include "agstzruleindex.h"

#include <calnotification.h>

#include "agsinstanceiterator.h"

#include "agmdebug.h"

#include <e32math.h>

#include <e32property.h>

#include <s32file.h>

// Compact threshold dependent on the number of operations

const TInt KCompactOperationsThreshold = 32;

/** This is called when opening an agenda file

@internalComponent

 */

CAgnEntryModel* CAgnEntryModel::NewL(CAgnServFile* aAgnServerFile)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aAgnServerFile);

	CleanupStack::Pop();

	return (self);

	}

/** Constructs a CAgnEntryModel object

@internalComponent

 */

void CAgnEntryModel::ConstructL(CAgnServFile* aAgnServerFile)

	{

	iUpdateAlarm = ETrue;

	iModelStreamIdSet = CAgnModelStreamIdSet::NewL();

	iEntryManager = CAgnEntryManager::NewL();

	iNextLocalUidValue = 1;

	iNextAttachmentUid = 1;

	if ( aAgnServerFile )

		{//When opening a file

		iAgnServerFile = aAgnServerFile;

		iSimpleEntryTable = CAgnSimpleEntryTable::NewL(*this);

        iExtractor = new (ELeave) TAgnInstanceExtractor(*iSimpleEntryTable);

		iCategoryIndex = CAgnCategoryIndex::NewL();

		iAttachmentIndex = new (ELeave) CAgnAttachmentIndex;

		CreateAlarmForServerL();

		}

	iIndexFileIsDirty = ETrue; 	// for safety assume that the index

					// file is out of date. We can correct this

					// when we read the file

	iIndexFileIsPresent = ETrue; // Assume the index file is present. 

	                             // First attempt to read it will update this

	                             // if it is not there.

	iTzRuleIndex = NULL;

	}

/** 

Frees all resources owned by the agenda model, prior to its destruction. 

@internalComponent

@capability None

*/

CAgnEntryModel::~CAgnEntryModel()

	{

	ResetRollback();

	delete iCategoryIndex;

	delete iAttachmentIndex;

	delete iTzRuleIndex;

	delete iExtractor;	

	delete iSimpleEntryTable;

	delete iAlarm;

	delete iModelStreamIdSet;

	delete iEntryManager;

	delete iCalConverter;

	}

const CAgnServFile& CAgnEntryModel::AgnServFile()

	{

	return *iAgnServerFile;

	}

/**

 * Resets delete rollback array before the callback

 */	

void CAgnEntryModel::ResetDeleteRollbackArray()

	{

	iDeleteRollbackArray.ResetAndDestroy();

	}

/** Load up the stream network

 */

void CAgnEntryModel::DoOpenL(const TStreamId& aModelStreamId)

	{

	delete iCalConverter;

	iCalConverter = NULL;

	// Check if a calendar converter is needed (old version file)

	//

	TAgnVersion fileVersion;

	CalCommon::TCalFileVersionSupport status;

	iAgnServerFile->GetFileVersionSupportStatusL(fileVersion,status);

	if ( status == CalCommon::EFileNeedsConverting )

		{

		if ( iAgnServerFile->IsReadOnly() )

			{

			User::Leave(KErrAccessDenied);

			}

		iCalConverter = CalFileVersionUtils::CreateConverterL(fileVersion, *iAgnServerFile);

		iModelStreamIdSet->LoadL(StreamStore(), aModelStreamId, *iCalConverter);

		}

	else

		{

		iTzRuleIndex = CAgnTzRuleIndex::NewL(*iAgnServerFile->Dictionary(), *iAgnServerFile->StoreL());

		iModelStreamIdSet->LoadL(StreamStore(), aModelStreamId);

		//If the Calendar file needs to be converted, CheckTzDbModificationL should be called after the file conversion is completed (in method LoadNewStreamStoreL). 

		TAgnVersion curVersion = CalFileVersionUtils::CurrentFileVersion();

		if(status == CalCommon::EFileIsCurrentVersion && !(fileVersion == curVersion))

			{

			//access to here means the format of index file has been changed but not to the rest

			//Changing the index file format does not cause DC but we need to ignore the old index files

			iIndexFileIsDirty = EFalse;

			iIndexFileIsPresent = EFalse;

			// Mark the existing index file as dirty and delete them.

			// Trap the leave to keep things running, but there is nothing

			// we can do if the file can't be deleted.

			TRAP_IGNORE(MarkIndexFileAsDirtyL());

			//Change the version of file to be current version.

			TRAP_IGNORE(iModelStreamIdSet->ChangeFileVersionL(StreamStore(), aModelStreamId, curVersion));

			}

		}

	GetFileIdL();

	InternalizeNextUidValuesL();

	InternalizeEntryManagerL();

	}

void CAgnEntryModel::CheckTzDbModificationL()

	{

	if(iTzRuleIndex)

		{

		iTzRuleIndex->CheckTzDbModificationL(*iAgnServerFile);

		}

	}

/** Opens an existing model store, whose root ID is aModelStreamId in the store aStore.

@capability None

@param aStore The store in which the model's data is stored.

@param aId The root stream ID of the store aStore.

@internalComponent

*/

void CAgnEntryModel::OpenL(CStreamStore& aStore, const TStreamId& aModelStreamId) 

	{	

	Reset();

	iEntryManager->SetStore(aStore);

	DoOpenL(aModelStreamId);

	}

TStreamId CAgnEntryModel::CreateL(CStreamStore& aStore) 

	{

	Reset();

	iEntryManager->SetStore(aStore);

	TStreamId headStreamId = iModelStreamIdSet->CreateL(aStore, CalFileVersionUtils::CurrentFileVersion());

	// save the next unique id value to the store

	iNextLocalUidValue = 1;

	iNextAttachmentUid = 1;

	ExternalizeNextUidValuesL();

	// save the entry store object to the store

	ExternalizeEntryManagerL();

	TTime creationDate; 

	creationDate.UniversalTime();

	iFileId = creationDate.Int64();

	TInt threeDidgit=Math::Random() % 1000;

	iFileId = iFileId - threeDidgit;// Ensure the file ID is unique even when two files have been created at the same time.

	ExternalizeFileIdL(aStore, iModelStreamIdSet->FileInformationStreamId());

	StreamStore().CommitL();

	return (headStreamId);

	}

void CAgnEntryModel::ExternalizeFileIdL(CStreamStore& aStore, const TStreamId& aStreamId) const

	{

	RStoreWriteStream out;

	// save file id

	out.ReplaceLC(aStore, aStreamId);

	out << iFileId;

	out.CommitL();

	CleanupStack::PopAndDestroy(); //out

	}

/**

Adds aEntry to the store and returns its resulting entry id.

@capability None

*/

TAgnEntryId CAgnEntryModel::DoAddEntryL(CAgnEntry& aEntry)

	{

	// If local UID is not set or if it's already used, then the entry is assigned a new local uid.

	TBool useNextLocalUid = EFalse;

	if (aEntry.LocalUid() == 0 || iSimpleEntryTable->GetEntry(aEntry.LocalUid()) != NULL)

		{

		useNextLocalUid = ETrue;

        while (iSimpleEntryTable->GetEntry(++iNextLocalUidValue) != NULL)

            {

            }

       	aEntry.SetLocalUid(iNextLocalUidValue);

		}

	TAgnEntryId nullId;

	aEntry.SetEntryId(nullId);

	StoreExternalAttributesL(aEntry);

	CopyAttachmentFileToDifferentPlaceL(aEntry);

	//Add the tz rules in the entry to tz rule index before it is stored in entry manager.

	if(iTzRuleIndex)

		{

		iTzRuleIndex->AddTzRuleL(aEntry);

		}

	TStreamId newStreamId = iEntryManager->AddEntryL(aEntry);

	if ( newStreamId != KNullStreamId )

		{

		iModelStreamIdSet->EntryStreamIdSet().AddL(newStreamId);

		}

	TAgnEntryId entryId = aEntry.EntryId();

	if ( useNextLocalUid )

		{

		ExternalizeNextUidValuesL();			

		}

	iEntryManager->StoreBuffersL();

	ExternalizeEntryManagerL();

	UpdateIndexL(aEntry, NULL, EAdd);

	// Don't commit on add. CommitL is called from CalInterimAPI after a number have been added.

	return (entryId);

	}

//It could copy the attachment to a different drive if it is the same as the existing one but with a different drive name

//or, it could copy the attachment form a different calendar file folder.

void CAgnEntryModel::CopyAttachmentFileToDifferentPlaceL(CAgnEntry& aEntry)

    {

    const TInt KAttachCount = aEntry.AttachmentCount();

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

        {

        CAgnAttachment& attach = aEntry.Attachment(ii);

        if (attach.Uid() && attach.Type() == CCalContent::EDispositionInline)

            {

            CAgnAttachmentFile* attachFile = static_cast<CAgnAttachmentFile*>(&attach);

            if(IsAttachmentFileFromSameSessionL(attachFile->FileName()))

                {

                const TDesC& existFileName = iAttachmentIndex->FileName(attach.Uid());

                if(existFileName != KNullDesC())

                    {//There exists an attachment with same uid 

                    TDriveName oldDrive = existFileName.Left(2);

                    TDriveName newDrive = attachFile->Drive();

                    if(oldDrive.CompareF(newDrive) != 0)//drive is different

                        {

                    //Copy file to a new drive with the same name

                        HBufC* newfileName = existFileName.AllocLC();

                        newfileName->Des().Replace(0,2,newDrive);

                        iAgnServerFile->CopyFileL(existFileName, newfileName->Des());

                        attachFile->SetFileNameL(*newfileName);

                        CleanupStack::PopAndDestroy(newfileName);

                        }

                    }

                }

            else if (iAgnServerFile->FileExistsL(attachFile->FileName())) 

                { //Attachment has been copied from a different calendar session

                TParsePtrC parseOriginalFile(attachFile->FileName()); 

                HBufC* fileName = GenerateFilenameLC(parseOriginalFile.Drive(), parseOriginalFile.NameAndExt());

                iAgnServerFile->CopyFileL(attachFile->FileName(), fileName->Des());

                attachFile->SetFileNameL(fileName->Des());

                CleanupStack::PopAndDestroy(fileName);

                attachFile->SetUid(iNextAttachmentUid++);

                }

            }

        }

    }

//Find out if the attachment is copied from a different server session

TBool CAgnEntryModel::IsAttachmentFileFromSameSessionL(const TDesC& aAttachmentFile)

    {

    TBool ret = ETrue;

    if(aAttachmentFile.FindF(iAgnServerFile->PrivatePath()) != KErrNotFound)

        {//The file name is something, for example,

        //c:\private\private\10003a5c\calendar_filename_a\0\attachmentfilename

        //We need to find out the calendar name where the attachment belongs to see if it is the same file as the current Calendar file. 

        TInt lengthPath = iAgnServerFile->PrivatePath().Length();

        const TInt lengthDrive = 2;

        //tempRemovedPath1 =  calendar_filename_a\0\attachmentfilename

        TPtrC tempRemovedPath1(aAttachmentFile.Mid(lengthPath + lengthDrive));

        //tempRemovedPath2 =  calendar_filename_a

        TPtrC tempRemovedPath2(tempRemovedPath1.Left(tempRemovedPath1.Locate('\\')));

        //calName = calendar_filename

        TPtrC calName(tempRemovedPath2.Left(tempRemovedPath2.LocateReverse('_')));

        TParsePtrC parseFile(iAgnServerFile->FileName()); 

        if(calName.CompareF(parseFile.NameAndExt()) != 0)

            {

            ret = EFalse;

            }

        }

    return ret;

    }

// aEntry is the entry that has been changed. If the change is an update, then aOriginalEntry gives 

// details about the original entry.

void CAgnEntryModel::NotifyChangeL(const CAgnServerSession& aSession, CAgnEntry* aEntry, 

									 MCalChangeCallBack2::TChangeType aChangeType, CAgnInstanceInfo* aOriginalEntry)

	{

	TAgnChange change;

	change.iOperationType = aChangeType;

	if ( aEntry )

		{

		change.iEntryType = aEntry->Type();

		change.iEntryId = aEntry->LocalUid();

		change.iRepeatRule = aEntry->RptDef();

		change.iStartTimeOfEntryUtc = aEntry->StartTime().UtcL();

		change.iEndTimeOfEntryUtc = aEntry->ValidToTimeLocalL();

		if ( aOriginalEntry )

			{

			change.iOriginalRepeatRule = aOriginalEntry->RptDef();

			change.iOriginalStartTimeUtc = aOriginalEntry->StartTimeUtc();

			change.iOriginalEndTimeUtc = aOriginalEntry->EndTimeUtc();

			}

		else

			{

			change.iOriginalRepeatRule = NULL;

			change.iOriginalStartTimeUtc = Time::NullTTime();

			change.iOriginalEndTimeUtc = Time::NullTTime();

			}

		}

	else

		{

		change.iEntryType = CCalEntry::EAppt;

		change.iEntryId = 0;

		change.iStartTimeOfEntryUtc = Time::NullTTime();

		change.iEndTimeOfEntryUtc = Time::NullTTime();

		change.iRepeatRule = NULL;

		change.iOriginalStartTimeUtc = Time::NullTTime();

		change.iOriginalEndTimeUtc = Time::NullTTime();

		change.iOriginalRepeatRule = NULL;

		}

	change.iSession = const_cast<CAgnServerSession*>(&aSession);

	GetFileIdL();

	change.iFileId = iFileId;

	NotifySessionsOfChangeL(change);

	}

void CAgnEntryModel::NotifySessionsOfChangeL(const TAgnChange& aChange)

	{

	RPointerArray<CAgnServerSession> sessions;

	CleanupClosePushL(sessions);

	iAgnServerFile->Server().FetchSessionsL(sessions);

	const TInt count = sessions.Count();

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

		{

		sessions[i]->AddChangeL(aChange);

		}

	CleanupStack::PopAndDestroy(&sessions); // sessions.Close()

	}

void CAgnEntryModel::NotifyPublishAndSubscribeL(TAgnChangeFilter& aChangeFilter)

	{

	// if publish and subcribe is enabled...	

	if ( aChangeFilter.PubSubEnabled() )

		{

		// ...get and set the Publish and Subscribe data

		TCalPubSubData calPubSubData;

		calPubSubData.iFileNameHash = iAgnServerFile->FileNameHash();

		calPubSubData.iTimeOfChangeUtc.UniversalTime(); 

		TPckgBuf<TCalPubSubData> calBuf(calPubSubData);

		// publish the update

		if ( aChangeFilter.TodoChanged() )

			{

			User::LeaveIfError(RProperty::Set(KCalPubSubCategory, ECalPubSubTodoNotification, calBuf));

			}

		else

			{

			User::LeaveIfError(RProperty::Set(KCalPubSubCategory, ECalPubSubEventNotification, calBuf));

			}

		aChangeFilter.SetPubSubChange(TAgnChangeFilter::ENoChange);

		}

	}

/**

Add a entry to the file. This function decides whether a new entry should be added or if an existing entry 

should be replaced. It also handles the adding of child entries.

@internalComponent

@return the TAgnEntryId of the newly added entry.

@param aEntry The entry being stored.

@param aChangeFilter Specifies the notification filter for the session adding the entry.

@leave KErrArgument If aEntry is a parent but contains a recurrence Id.

@leave KErrNotFound If aEntry is a child entry whose parent entry doesn't exist in the calendar store.

@leave KErrArgument If aEntry is a child entry with a different time mode (fixed / floating) to its parent entry.

*/

TAgnEntryId CAgnEntryModel::StoreL(CAgnEntry& aEntry, TAgnChangeFilter* aChangeFilter)

	{

	iChangeFilter = aChangeFilter;

	TAgnEntryId returnId;

	if ( aEntry.GsDataType() == CGsData::EParent )

		{

		_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Entry to be stored is a parent");)

		_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Checking if an entry with the same GUID already exists");)

		// it is a parent entry

		CAgnEntry* existingEntryToReplace = FetchEntryL(aEntry.Guid());

		if (existingEntryToReplace == NULL && aEntry.LocalUid() != 0)

			{

			//This is used for the case when sync a updated entry from remote sync server.

			//Some servers may filter out GUID assigned by client and only info we can get

			//to update a entry is by using its local ID.

			_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Attempting to fetch using localUid to fetch the entry from the server");)

			existingEntryToReplace = FetchEntryL(aEntry.LocalUid());

			}

		if ( existingEntryToReplace)

			{

			_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: An entry with the same GUID already exists");)

			CleanupStack::PushL(existingEntryToReplace);

			if (existingEntryToReplace->Type() == aEntry.Type())

				{

				_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Existing entry type matches incoming entry's type");)

				// if this entry is the same type as the existing entry, update the existing entry

				aEntry.SetEntryId(existingEntryToReplace->EntryId());

				aEntry.SetLocalUid(existingEntryToReplace->LocalUid());

				_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Setting Ids using the existing entry: LocalUid= %d, EntryId= %d", aEntry.LocalUid(),aEntry.EntryId().Value());)

			        const RArray<TGsChildRefData>& KChildIds = existingEntryToReplace->ChildIds();

			        const TInt KCount = KChildIds.Count();

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

			            {

			            aEntry.AddChildIdL(KChildIds[ii]);

			            }

				aEntry.SetLastModifiedDate();

				UpdateEntryL(aEntry, iChangeFilter, ETrue);

				returnId = aEntry.EntryId();

				}

			else 

				{

				_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Existing entry types is different to incoming entry's type");)

				_DBGLOG_VERBOSE(AgmDebug::DebugLog("StoreL: Delete the existing entry and add the incoming entry as a new one");)

				// if the entry is a different type, add the new one first and delete only later

                // This change is needed if the entry having attachments, it will be shared by two 

                //entries, so that attachments will not be deleted, while deleting it later. 

				returnId = AddEntryL(aEntry);

				DeleteEntryL(*existingEntryToReplace, ETrue, iChangeFilter);

				}

			CleanupStack::PopAndDestroy(existingEntryToReplace);