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

#include "agsasyncdelete.h"

#include "agscategoryindex.h"

#include "agscategorylist.h"

#include "agsentrymanager.h"

#include "agsfileconverter.h"

#include "agsfilesearch.h"

#include "agsentrymodel.h"

#include "agsattachmentindex.h"

#include "agmutil.h"

#include "agsmain.h"

#include "agspermanentdata.h"

#include "agssess.h"

#include "calcommonimpl.h"

#include "agmdebug.h"

#include "agstzruleindex.h"

#include "agmcalendarinfo.h"

#include <apparc.h>

#include <s32file.h>

const TInt KAgnCompactionThresholdInBytes=10240;

//

// CAgnServFile

//

// Make sure the active object has the same priority as the server

// If it's higher, the client will be blocked when the server

// does an extended operation. If lower, the server won't ever

// get around to the extended tasks, unless it is left alone by

// all clients.

CAgnServFile::CAgnServFile(RFs& aFs, CAgnServer& aAgnServer) :

	CActive(CActive::EPriorityStandard),

	iAgnServer(aAgnServer),

	iFs(aFs),

	iActiveStep(CCalAsyncTaskManager::ENoAction),

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	iShutdownNotification(EFalse),

#endif

	iIsFileDisabled(EFalse)

	{

	CActiveScheduler::Add(this);

	iRefCount = 0;

	}

CAgnServFile* CAgnServFile::NewL(RFs& aFs, CAgnServer& aAgnServer)

	{

	CAgnServFile* self = new(ELeave)CAgnServFile(aFs, aAgnServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CAgnServFile::ConstructL()

	{

	const TInt KMessageVectorGranularity = 4; // unlikely to be 4 messages simultaneously

	iMessageVector = new (ELeave) CArrayFixFlat<TAgnMessageToComplete> (KMessageVectorGranularity);

	iFileShutdownDelayTimer = CAgnServFileShutdownDelayTimer::NewL(*this);

	}

CAgnServFile::~CAgnServFile()

	{

	CloseAgendaImmediately();

	delete iFileName;

	delete iMessageVector;

	delete iCategoryList;

	delete iAsyncDelete;

	delete iFileShutdownDelayTimer;

	}

CAgnTlsProxy* CAgnServFile::TimeZoneConverter() const

	{

	return iAgnServer.TimeZoneConverter();

	}

void CAgnServFile::Start()

//

// Set the object to the active state and make a request

//

	{

	if ( ! IsActive())

		{

		SetActiveAndMakeRequest();

		}

	}

void CAgnServFile::RunL()

	{

	if (iActiveStep == CCalAsyncTaskManager::ENoAction)

		{

		return;

		}

	TBool completed = EFalse;

	TRAPD(err, completed = DoStepL());

	if (err != KErrNone )

		{

		DoTaskCompleteL(err, iSession);

		}

	else if ( ! completed)

		{

		// The current step is not complete, reschedule the active object

		// do some more work.

		SetActiveAndMakeRequest();

		}

	}

TBool CAgnServFile::HasServerSession() const

	{

	return (iSession != NULL);

	}

const TDesC& CAgnServFile::PrivatePath() const

	{

	if (iAgnServer.FileMgr())

		{

		return iAgnServer.FileMgr()->PrivatePath();

		}

	return KNullDesC();

	}

void CAgnServFile::DoCancel()

	{

	// do nothing

	}

void CAgnServFile::SetActiveAndMakeRequest()

//

// Set the object to the active state and make a request

//

	{

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status,KErrNone);

	}

const TDesC& CAgnServFile::FileName() const

	{

	if (iFileName)

		{

		return *iFileName;

		}

	return KNullDesC();

	}

void CAgnServFile::GetAttachmentFolderNameL(TDes& aFolderName)

	{

	GetAttachmentFolderNameL(FileName(), aFolderName);

	}

void CAgnServFile::GetAttachmentFolderNameL(const TDesC& aFileName, TDes& aFolderName)

	{

	// extension added to calender file name to give folder name for storing attachments

	_LIT(KCalAttachmentsExtension, "_a");

	_LIT(KCalDirectory, "\\");

	__ASSERT_ALWAYS(aFileName.Length() + KCalAttachmentsExtension().Length() + KCalDirectory().Length() <= aFolderName.MaxLength(), User::Leave(KErrArgument));

	aFolderName.Copy(aFileName);

	aFolderName.Append(KCalAttachmentsExtension);

	aFolderName.Append(KCalDirectory);

	}

void CAgnServFile::OpenAgendaL(const TDesC& aFilename, CalCommon::TCalFileVersionSupport& aStatus)

	{

	_DBGLOG_BASIC(AgmDebug::DebugLog("Opening Calendar File - '%S'",&aFilename);)

	if(aFilename.Length() > KMaxFileName)

		{

		_DBGLOG_BASIC(AgmDebug::DebugLog("KErrArgument:  Calendar filename length is greater than max filename length permitted");)

		User::Leave(KErrArgument);

		}

	// Check the file exists

	if (FileExistsL(aFilename) == EFalse)

		{

		_DBGLOG_BASIC(AgmDebug::DebugLog("KErrNotFound: Filename - %S not found", &aFilename);)

		User::Leave(KErrNotFound);

		}

	// If the file is in ROM, should leave

	if (aFilename.Length() > 2)

		{

		TDriveName driveName;

		driveName.Append(aFilename[0]);

		driveName.UpperCase();

		TDriveUnit drive(driveName);

		TDriveInfo driveInfo;

		User::LeaveIfError(iFs.Drive(driveInfo, drive));

		if (driveInfo.iDriveAtt == KDriveAttRom)

			{

			_DBGLOG_BASIC(AgmDebug::DebugLog("KErrNotSupported: The file is in ROM. This is not supported");)

			User::Leave(KErrNotSupported);

			}

		}

	iFileName = aFilename.AllocL();

	iReadOnly = FileIsReadOnlyL(FileName());

	CreateFileStoreL(aFilename);

	// Check that the file version is compatible

	// with the entry model's version

	TAgnVersion version;

	GetFileVersionSupportStatusL(version, aStatus);

	if(aStatus == CalCommon::EUnsupportedFileVersion)

		{

		User::Leave(KErrNotSupported);

		}

	// Create a model for this file

	CreateModelForFileL();

	}

void CAgnServFile::ReopenAgendaAfterRestoreL()

	{

	//We only build index if it was built before restore started.

	TBool toBuiildIndex = iIndexesBuilt;

	CreateFileStoreL(*iFileName);//iIndexesBuilt is set to EFalse in this function

	CreateModelForFileL();

	if (toBuiildIndex)

		{

		while(iIndexesBuilt ==0)

			{

			DoBuildIndexStepL();

			}

		TRAPD(err, iModel->BuildIndexCompleteL());

		if(err != KErrNone && err != KErrServerBusy)

			{

			User::Leave(err);

			}

		iModel->CommitL();

		}

	Model()->CheckTzDbModificationL();

	if(RefreshTzRules())

		{

		TPckgBuf<NTzUpdate::TTzRulesChange> pubSubBuf;

		if(KErrNone == RProperty::Get(NTzUpdate::KPropertyCategory, NTzUpdate::ETzRulesChange, pubSubBuf))

			{

			TTime tzChange = pubSubBuf().iUTCTimeOfRulesChange;

			Model()->HandleTzRulesChangeL(tzChange);

			}

		SetRefreshTzRules(EFalse);

		}

	}

void CAgnServFile::CreateFileStoreL(const TDesC& aFilename)

	{

	CFileStore* store = NULL;

	iDictionary = CApaProcess::ReadRootStreamLC(iFs, store, aFilename, EFileRead);

	CleanupStack::Pop(); // dictionary

	CleanupStack::PushL(store);

	iModelStreamId = iDictionary->At(KUidAgnModel);

	if (iModelStreamId == KNullStreamId)

		{

		_DBGLOG_BASIC(AgmDebug::DebugLog("KErrCorrupt: Corrupt model stream");)

		User::Leave(KErrCorrupt);

		}

	CleanupStack::PopAndDestroy(store);

	// Create the permanent file store

	//      

	if (iReadOnly)

		{

		iStore =  CPermanentFileStore::OpenL(iFs,aFilename,EFileShareAny|EFileRead);

		}

	else

		{

		iStore =  CPermanentFileStore::OpenL(iFs,aFilename,EFileShareAny|EFileRead|EFileWrite);

		}

	CAgnCalendarInfo* info(NULL);

	TStreamId calendarInfoStreamId = iDictionary->At(KUidAgnCalendarInfo);

	if (calendarInfoStreamId != KNullStreamId)

		{

		// Calendar info has been set on this file

		RStoreReadStream readStream;

		readStream.OpenLC(*iStore, calendarInfoStreamId);

		info = CAgnCalendarInfo::NewL();

		CleanupStack::PushL(info);

		info->FileInternalizeL(readStream);

		info->SetIsValid(ETrue);

		iIsFileDisabled = (!info->Enabled());

		CleanupStack::PopAndDestroy(info);

		CleanupStack::PopAndDestroy(&readStream);

		}

	}

void CAgnServFile::GetFileVersionSupportStatusL(TAgnVersion& aFileVersion, CalCommon::TCalFileVersionSupport& aStatus)

	{

	RStoreReadStream readStream;

	readStream.OpenLC(*(StoreL()),iModelStreamId);

	readStream >> aFileVersion;

	CleanupStack::PopAndDestroy(&readStream);

	CalFileVersionUtils::FileVersionSupportedL(aFileVersion, aStatus);

	}

void CAgnServFile::CreateModelForFileL()

	{

	// Create a model for this file

	iModel = CAgnEntryModel::NewL(this);

	// Set the model to run in server mode

	// Open the requested file

	iModel->OpenL(*iStore, iModelStreamId);

	iIndexesBuilt = EFalse;

	iProgressTotal = 0; 

	if (!iCategoryList)

		{

		iCategoryList = CAgnCategoryList::NewL(*this);

		}

	iModel->CategoryIndex().SetCategoryList(iCategoryList);

	// we've got here, so the file isn't on the z:\ drive

	SaveCategoryListL();

	SetFileNameHashL();

	}

void CAgnServFile::SetFileNameHashL()

	{

	// There is a file associated with the model

	TParsePtrC parse(FileName());

	TPtrC drive(parse.Drive());

	TPtrC name(parse.Name());

	HBufC* fileNameAndDriveOnly = HBufC::NewLC(drive.Length() + name.Length());

	TPtr ptr = fileNameAndDriveOnly->Des();

	ptr.Append(drive);

	ptr.Append(name);

	iFileNameHash = FoldAndGenerateHashL(*fileNameAndDriveOnly);

	CleanupStack::PopAndDestroy(fileNameAndDriveOnly);

	}

TUint32 CAgnServFile::FileNameHash() const

	{

	return iFileNameHash;

	}

void CAgnServFile::SaveCategoryListL()

	{

	TStreamId streamId = DictionaryLookup(KUidAgnCategoryList);

	if (streamId == KNullStreamId)

		{

		// If the category list stream does not exist, create it.

		CreateCategoryListL();

		}

	else

		{

		// category stream exists, we are re-opening the file

		InternalizeCategoryListL(streamId);

		}

	iModel->RestoreCategoriesL();

	}

void CAgnServFile::CreateCategoryListL() const

	{

	TStreamId streamId = WriteCategoryListL(*iStore);

	AddStreamToDictionaryL(KUidAgnCategoryList, streamId);

	}

TStreamId CAgnServFile::WriteCategoryListL(CStreamStore& aStore) const

	{

	RStoreWriteStream writeStream;

	TStreamId streamId = writeStream.CreateLC(aStore);

	iCategoryList->ExternalizeL(writeStream);

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	return streamId;

	}

void CAgnServFile::InternalizeCategoryListL(const TStreamId& aStreamId)

	{

	RStoreReadStream readStream;

	readStream.OpenLC(*iStore,aStreamId);

	iCategoryList->InternalizeL(readStream);

	CleanupStack::PopAndDestroy(&readStream);

	}

void CAgnServFile::ExternalizeCategoryListL()

	{

	TStreamId streamId = DictionaryLookup(KUidAgnCategoryList);

	RStoreWriteStream writeStream;

	writeStream.ReplaceLC(*iStore,streamId);

	iCategoryList->ExternalizeL(writeStream);

	writeStream.CommitL();

	CleanupStack::PopAndDestroy(&writeStream);

	User::LeaveIfError(iStore->Commit());

	}

CAgnCategoryList& CAgnServFile::CategoryList() const

	{

	return *iCategoryList;

	}

void CAgnServFile::StartBuildIndex(TAgnMessageToComplete& aMessageToComplete)

	{

	if (iIndexesBuilt)

		{

		// The indexes have already been bulit.

		aMessageToComplete.Message().Complete(KErrNone);

		return;

		}

	// Add this request to the async. index build request queue.

	//

	TRAPD(err, AddAsyncRequesterL(aMessageToComplete));

	if (err != KErrNone)

		{

		aMessageToComplete.Message().Complete(err);

		}

	else if (iActiveStep != CCalAsyncTaskManager::EBuildIndex)

		{

		DoStartBuildIndex();

		}

	}

void CAgnServFile::RequestProgressL(TAgnMessageToComplete& aMessageToComplete)

	{

	if (iActiveStep == CCalAsyncTaskManager::ENoAction)

		{

		// there are no progress to report

		aMessageToComplete.Message().Complete(KErrNone);

		return;

		}

	// Add this request to the async. index build request queue.

	//

	TRAPD(err, AddAsyncRequesterL(aMessageToComplete));

	if (err != KErrNone)

		{

		aMessageToComplete.Message().Complete(err);

		// If are already building the indexes then don't broadcast the error.

		}

	}

void CAgnServFile::DoStartBuildIndex()

	{

	// If we are already building the index then there is nothing

	// more to do, this request will be completed when the index has been

	// built.

	//

	// Start building the index.

	iModel->ResetIndexes();

	if ( ! iModel->StreamsAreEmpty())

		{			

		// Report % complete and continue building index.

		iActiveStep = CCalAsyncTaskManager::EBuildIndex;

		iIndexesBuilt = EFalse;

		iProgressTotal = 0;

		Start();

		}

	else

		{

		// Agenda is empty, nothing to do for indexes. Complete immediately.

		iIndexesBuilt = ETrue;

		CompleteRequests(ETrue, KErrNone, iSession);

		}	

	}

TBool CAgnServFile::AreIndexesBuilt() const

	{

	return iIndexesBuilt;

	}

// static function which can be added to a cleanup item on cleanup stack

void CAgnServFile::CloseAgenda(TAny* aFile)

	{

	CAgnServFile* file = static_cast<CAgnServFile*>(aFile);

	file->CloseAgendaImmediately();

	delete file;

	}

void CAgnServFile::DoSaveIndexFile()

	{

	if (iModel == NULL)

		{

		return;

		}

	if (iIndexesBuilt && iModel->IsIndexFileDirty())

		{

		TInt trapErr = KErrNone;

		TRAP(trapErr, iModel->SaveIndexFileL());

		if (trapErr != KErrNone)

			{

			// if we can't save the index file, we need to

			// make sure that it is marked as dirty

			TRAP_IGNORE(iModel->MarkIndexFileAsDirtyL());

			}

		}

	}	

/** 

* Closes the calendar file in the current agenda server session immediately or after a delay.

* The delay is triggered using a timer owned by the calendar file. If a session then tries to access the same calendar file, the delay is cancelled and the file is not closed

* @param aCloseAgendaWithDelay ETrue if a delay is required before the closure of the calendar file, EFalse if the calendar file is to be closed immediately

*/