// Copyright (c) 2004-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:

//

// User includes

#include "SCHSTORE.H"

#include "SchLogger.h"

#include "SCHEDULE.H"

#include "SCHCLI.H"

#include "SCHEXEC.H"

#define UNUSED_VAR(a) a = a

// Constants

const TInt KMaxChangesBeforeCompact = 5;

//

//

// -----> SchBackupManagerUtils (header)

//

void SchBackupManagerUtils::Panic(TSchStorePanic aPanic)

	{

	_LIT(KSchStorePanic, "SchStore");

	User::Panic(KSchStorePanic, aPanic);

	}

//

// -----> CSchBackupManager (header)

//

CSchBackupManager::CSchBackupManager(RFs& aFsSession)

:	CActive(EPriorityIdle), iFsSession(aFsSession)

	{

	// construct backup filename

	iBackupFileName.Copy(KSchsvrBackupFileName);

	iBackupFileName[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive()); 

	CActiveScheduler::Add(this);

	}

CSchBackupManager::~CSchBackupManager()

	{

	// This will delete the store and close the compactor

	Cancel();

	//

	delete iScheduleIndex;

	delete iClientIndex;

	}

void CSchBackupManager::ConstructL()

	{

	iScheduleIndex = CSchScheduleIndex::NewL();

	iClientIndex = CSchClientIndex::NewL(iFsSession);

	}

/**

If this is called during a restore, we want to make sure we want to append

to existing structure not always create new object and just append to the queue

for example we want to append task to existing client if they have the same name

and priority not create another one.

*/

void CSchBackupManager::RestoreL(TPriQue<CClientProxy>& aClients, 

								TSglQue<CSchedule>& aTimeSchedules,

								CSchLogManager& aSchLogManager,TBool aBUR)

	{

	LOGSTRING("CSchBackupManager::RestoreL");

	// Open store

	CPermanentFileStore* store = OpenOrCreateBackupStoreLC();

	// Restore root stream (two pointers to other streams)

	RStoreReadStream stream;

	stream.OpenLC(*store, store->Root());

	stream >> iIndexStreamSchedules;

	stream >> iIndexStreamClients;

	CleanupStack::PopAndDestroy(); // stream

	// Restore clients

	iClientIndex->RestoreClientsL(aClients, *store, iIndexStreamClients, aSchLogManager,aBUR);

	// Restore schedules

	iScheduleIndex->RestoreSchedulesL(aTimeSchedules, *store, iIndexStreamSchedules);

	// Cleanup store.

	CleanupStack::PopAndDestroy(store);

	}

void CSchBackupManager::PerformStoreOperationL(TSchBackupOperation aAction, const CSchedule& aSchedule)

//

//	Perform an schedule-related operation.

//

	{

	LOGSTRING3("CSchBackupManager::PerformStoreOperationL - Schedule: %S (%d)", &aSchedule.Name(), aSchedule.Id());

	if(aSchedule.Persists())

		{

		// Cancel any compaction that may be going on

		Cancel();

		// Perform the operation

		CStreamStore* store = OpenOrCreateBackupStoreLC();

		CleanupRevertPushLC(*store);

		switch(aAction)

			{

		case ESchBackupOperationAdd:

			LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpAdd");

			iScheduleIndex->AddL(iIndexStreamSchedules, *store, aSchedule);

			break;

		case ESchBackupOperationEdit:

			LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpEdit");

			iScheduleIndex->EditL(iIndexStreamSchedules, *store, aSchedule);

			break;

		case ESchBackupOperationDelete:

			LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpDelete");

			iScheduleIndex->DeleteL(iIndexStreamSchedules, *store, aSchedule);

			break;

		default:

			__ASSERT_DEBUG(EFalse, User::Invariant());

			User::Leave(KErrNotSupported);

			}	

		// Save changes to store

		store->CommitL();

		CleanupStack::Pop(); // Store reversion cleanup item

		CleanupStack::PopAndDestroy(store);

		// Indicate the store has changed and attempt to compact 

		// the store, but only if the required number of store 

		// changes has been met

		StoreChangedL();

		}

	}

void CSchBackupManager::PerformStoreOperationL(TSchBackupOperation aAction, const CClientProxy& aClient)

//

//	Perform an schedule-related operation.

//

	{

	LOGSTRING2("CSchBackupManager::PerformStoreOperationL - Client: %S", &aClient.ExecutorFileName());

	// Cancel any compaction that may be going on

	Cancel();

	// Perform the operation

	CStreamStore* store = OpenOrCreateBackupStoreLC();

	CleanupRevertPushLC(*store);

	switch(aAction)

		{

	case ESchBackupOperationAdd:

		LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpAdd");

		iClientIndex->AddL(iIndexStreamClients, *store, aClient);

		break;

	case ESchBackupOperationEdit:

		LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpEdit");

		iClientIndex->EditL(iIndexStreamClients, *store, aClient);

		break;

	case ESchBackupOperationDelete:

		LOGSTRING("CSchBackupManager::PerformStoreOperationL - OpDelete");

		iClientIndex->DeleteL(iIndexStreamClients, *store, aClient);

		break;

	default:

		__ASSERT_DEBUG(EFalse, User::Invariant());

		User::Leave(KErrNotSupported);

		}

	// Save changes to store

	store->CommitL();

	CleanupStack::Pop(); // Store reversion cleanup item

	CleanupStack::PopAndDestroy(store);

	// Indicate the store has changed and attempt to compact 

	// the store, but only if the required number of store 

	// changes has been met

	StoreChangedL();

	}

void CSchBackupManager::RunL()

//

//	Perform a store compaction step

//

	{

	LOGSTRING("CSchBackupManager::RunL - Performing compaction step");

	// Is there any more processing required?

	if	(iStoreReclaimerCount() > 0)

		{

		// Yes, so start next step

		iStoreReclaimer.Next(iStoreReclaimerCount, iStatus);

		SetActive();

		LOGSTRING("CSchBackupManager::RunL - Requesting another compaction step");

		}

	else

		{

		// No, we've finised. Clean up previously allocated

		// resources

		iStoreReclaimer.Close();

		//

		TRAPD(errNotRef, iStoreOpenForCompaction->CommitL());

        UNUSED_VAR(errNotRef);

		delete iStoreOpenForCompaction;

		iStoreOpenForCompaction = NULL;

		// Set this to zero again...

		ResetStoreChanges();

		LOGSTRING("CSchBackupManager::RunL - Compaction complete");

		}

	}

void CSchBackupManager::DoCancel()

//

//	Cancel's any asynchronous store compaction

//

	{

	LOGSTRING("CSchBackupManager::RunL - Cancelling compaction");

	iStoreReclaimer.Release();

	iStoreReclaimer.Close();

	//

	TRAPD(errNotRef, iStoreOpenForCompaction->CommitL());

    UNUSED_VAR(errNotRef);

	delete iStoreOpenForCompaction;

	iStoreOpenForCompaction = NULL;

	}

void CSchBackupManager::StoreChangedL()

	{

	__ASSERT_DEBUG(!IsActive() && !iStoreOpenForCompaction, User::Invariant());

	if	(RecordStoreChange() >= KMaxChangesBeforeCompact)

		{

		// Open the store

		CStreamStore* store = OpenBackupStoreLC();

		// Prepare for compaction

		TInt count;

		iStoreReclaimer.CompactL(*store, count);

		iStoreReclaimerCount = count;

		// Safe to do this now

		iStoreOpenForCompaction = store;

		CleanupStack::Pop();

		// Start asynchronous compaction...

		iStoreReclaimer.Next(iStoreReclaimerCount, iStatus);

		SetActive();

		}

	}

CPermanentFileStore* CSchBackupManager::OpenBackupStoreLC()

	{

	return CPermanentFileStore::OpenLC(iFsSession, iBackupFileName, EFileWrite);

	}

CPermanentFileStore* CSchBackupManager::OpenOrCreateBackupStoreLC()

	{

	CPermanentFileStore* store = NULL;

	TInt error = KErrNone;

	TRAP(error, 

		store = CPermanentFileStore::OpenL(iFsSession, iBackupFileName, EFileWrite);

		);

	if	(error < KErrNone)

		{

		if	(error == KErrNotFound)

			{

			CreateEmptyBackupL();

			store = CPermanentFileStore::OpenL(iFsSession, iBackupFileName, EFileWrite);

			}

		else

			{

			User::Leave(error);

			}

		}

	LOGSTRING("CSchBackupManager::OpenOrCreateBackupStoreLC - store opened");

	CleanupStack::PushL(store);

	return store;

	}

void CSchBackupManager::CleanupRevertPushLC(CStreamStore& aStore)

	{

	CleanupStack::PushL(TCleanupItem(RevertStore, &aStore));

	}

void CSchBackupManager::RevertStore(TAny* aStore)

//

//	The Cleanup Item callback function which is used to rever the store

//	should a leave occur.

//

	{

	CStreamStore* store = reinterpret_cast<CStreamStore*>(aStore);

	store->Revert();

	LOGSTRING("CSchBackupManager::RevertStore - store reverted");

	}

/**

Creates an initialised empty store.

The creation process is performed as an atomic operation.

If the operation fails somewhere at the middle, CreateEmptyBackupL()

will cleanup after itself - the store file will be deleted,

iIndexStreamSchedules and iIndexStreamClients stream IDs will be reinitialised

with invalid values.

*/

void CSchBackupManager::CreateEmptyBackupL()

	{

	TRAPD(err, DoCreateEmptyBackupL());

	if(err != KErrNone)

		{

		//Cleanup & leave

		// If unable to delete file record the fact

		TInt err2 = iFsSession.Delete(iBackupFileName);

		if (err2 != KErrNone)

			{

			LOGSTRING2("CSchBackupManager::CreateEmptyBackupL - File delete error = %d", err2);

			}

		iIndexStreamSchedules = iIndexStreamClients = KNullStreamId;

		User::Leave(err);

		}

	}

/**

Creates an initialised empty store.

*/

void CSchBackupManager::DoCreateEmptyBackupL()

	{

	LOGSTRING("CSchBackupManager::CreateEmptyBackupL - trying to create new store");

	CPermanentFileStore* store = CPermanentFileStore::ReplaceLC(iFsSession, iBackupFileName, EFileWrite);

	store->SetTypeL(KPermanentFileStoreLayoutUid);	

	// Create emtpy schedule index stream

	CSchScheduleIndex* indexSchedule = CSchScheduleIndex::NewL();

	CleanupStack::PushL(indexSchedule);

	iIndexStreamSchedules = indexSchedule->CreateEmptyIndexL(*store);

	CleanupStack::PopAndDestroy(indexSchedule);

	// Create emtpy client index stream

	CSchClientIndex* indexClient = CSchClientIndex::NewL(iFsSession);

	CleanupStack::PushL(indexClient);

	iIndexStreamClients = indexClient->CreateEmptyIndexL(*store);

	CleanupStack::PopAndDestroy(indexClient);

	// Write root stream

	WriteRootStreamL(*store);

	// Finalise

	store->CommitL();							

	CleanupStack::PopAndDestroy(store);

	LOGSTRING("CSchBackupManager::CreateEmptyBackupL - new store created");

	}

void CSchBackupManager::WriteRootStreamL(CStreamStore& aStore)

//

//	Write the root stream which contains the two stream id's

//

	{

	LOGSTRING("CSchBackupManager::WriteRootStreamL - trying to write root stream");

	RStoreWriteStream stream;

	TStreamId id = stream.CreateLC(aStore);	

	// This writes a stream id - it doesn't write the actual

	// dictionary since this is written after every operation.

	stream << iIndexStreamSchedules;

	stream << iIndexStreamClients;

	// 

	stream.CommitL();						

    CleanupStack::PopAndDestroy();// outstream

	static_cast<CPermanentFileStore&>(aStore).SetRootL(id);

	LOGSTRING("CSchBackupManager::WriteRootStreamL - root stream written");

	}

//

// -----> CSchScheduleIndex (header)

//

CSchScheduleIndex::CSchScheduleIndex()

	{

	}

CSchScheduleIndex* CSchScheduleIndex::NewL()

	{

	CSchScheduleIndex* self = new(ELeave) CSchScheduleIndex;

	return self;

	}

void CSchScheduleIndex::RestoreSchedulesL(TSglQue<CSchedule>& aTimeSchedules, 

										CStreamStore& aStore, 

										TStreamId aDictionaryStreamId)

	{

	CSchScheduleDictionary* dictionary = DictionaryLC(aStore, aDictionaryStreamId);

	// Restore every schedule in the dictionary

	const TInt count = dictionary->Count();

	LOGSTRING2("CSchScheduleIndex::RestoreSchedulesL - read %d dictionary entries", count);

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

		{

		// Get stream

		TStreamId stream = dictionary->AtIndex(i);

		// Restore schedule from stream

		CSchedule* schedule = CSchedule::NewL(static_cast<CFileStore&>(aStore), stream);

		// Save schedule

		aTimeSchedules.AddLast(*schedule); // takes ownership

		LOGSTRING3("CSchScheduleIndex::RestoreSchedulesL - restored schedule: %S, %d", &schedule->Name(), schedule->Id());

		}

	CleanupStack::PopAndDestroy(dictionary);

	}

TStreamId CSchScheduleIndex::CreateEmptyIndexL(CStreamStore& aStore) const

	{

	CSchScheduleDictionary* dictionary = CSchScheduleDictionary::NewLC();

	RStoreWriteStream stream;

	TStreamId id = stream.CreateLC(aStore);

	stream << *dictionary;

	stream.CommitL();

	CleanupStack::PopAndDestroy(2); // stream, dictionary

	return id;

	}

void CSchScheduleIndex::AddL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule)

//

//	Saves the specified schedule to the store and adds a new entry to the

//	dictionary.

//

	{

	LOGSTRING2("CSchScheduleIndex::AddL - adding a new schedule (id is %d)", aSchedule.Id());

	RStoreWriteStream stream;

	TStreamId id = stream.CreateLC(aStore);

	stream << aSchedule;

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

	// Read the dictionary and update an entry

	CSchScheduleDictionary* dictionary = DictionaryLC(aStore, aIndexStream);

	dictionary->AssignL(aSchedule.Id(), id);

	// Store the dictionary

	StoreDictionaryL(aStore, *dictionary, aIndexStream);

	CleanupStack::PopAndDestroy(dictionary);

	LOGSTRING("CSchScheduleIndex::AddL - new schedule added okay");

	}

void CSchScheduleIndex::EditL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule)

//

//	Replace an existing stream with the contents of aSchedule. 

//

	{

	// Locate the existing stream (to be replaced)

	CSchScheduleDictionary* dictionary = DictionaryLC(aStore, aIndexStream);

	LOGSTRING2("CSchScheduleIndex::EditL - editing schedule with id of %d", aSchedule.Id());

	TStreamId id = dictionary->At(aSchedule.Id());

	CleanupStack::PopAndDestroy(dictionary);

	if	(id == KNullStreamId)

		{

		// Wasn't found, add it instead...

		LOGSTRING("CSchScheduleIndex::EditL - schedule wasn't found, adding new entry to the store");

		AddL(aIndexStream, aStore, aSchedule);

		}

	else

		{

		// Replace - the original stream is orphaned but the new

		// stream retains the old id.

		LOGSTRING("CSchScheduleIndex::EditL - replacing original stream");

		RStoreWriteStream stream;

		stream.ReplaceLC(aStore, id);

		stream << aSchedule;

		stream.CommitL();

		CleanupStack::PopAndDestroy(); // stream

		}

	}

void CSchScheduleIndex::DeleteL(TStreamId aIndexStream, CStreamStore& aStore, const CSchedule& aSchedule)

//

//	Remove an existing schedule from the store.

//

	{

	// Locate the existing stream (to be deleted)

	CSchScheduleDictionary* dictionary = DictionaryLC(aStore, aIndexStream);

	LOGSTRING2("CSchScheduleIndex::DeleteL - deleting schedule with id of %d", aSchedule.Id());

	TStreamId id = dictionary->At(aSchedule.Id());

	if	(id == KNullStreamId)

		{

		LOGSTRING("CSchScheduleIndex::DeleteL - schedule wasn't found! Would panic in debug");

		__ASSERT_DEBUG(EFalse, SchBackupManagerUtils::Panic(SchBackupManagerUtils::ESchBackupManagerScheduleStreamToDeleteNotFound));

		}

	else

		{

		// Remove the stream

		aStore.DeleteL(id);

		// Save changes to store - we have to do this here since

		// we must assure that the store is fully updated before

		// we remove this stream from the dictionary (in order to 

		// maintain integrity).

		aStore.CommitL();

		// Remove entry from the stream dictionary

		dictionary->Remove(aSchedule.Id());

		StoreDictionaryL(aStore, *dictionary, aIndexStream);

		}

	CleanupStack::PopAndDestroy(dictionary);

	}

CSchScheduleIndex::CSchScheduleDictionary* CSchScheduleIndex::DictionaryLC(CStreamStore& aStore, TStreamId aIndexStream)

	{

	LOGSTRING("CSchScheduleIndex::DictionaryLC - restoring dictionary");

	CSchScheduleDictionary* dictionary = CSchScheduleDictionary::NewLC();

	RStoreReadStream stream;

	stream.OpenLC(aStore, aIndexStream);

	stream >> *dictionary;

	CleanupStack::PopAndDestroy(); // stream