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

// User includes
#include <logcli.h>
#include "logservpanic.h"

// Constants
const TInt KTimerDelay = 10000000; // 10 seconds


/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogServBackupManager (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogServBackupManager::CLogServBackupManager(TInt aPriority)
:	CTimer(aPriority)
	{
	CActiveScheduler::Add(this);
	}

CLogServBackupManager::~CLogServBackupManager()
	{
	__ASSERT_DEBUG(iObservers.Count() == 0, Panic(ELogBackupObserversStillRegistered));
	Cancel();

	// Unregister ourselves with backup server
	if (iBackup)
		{
		if	(iDatabaseName)
			iBackup->DeregisterFile(*iDatabaseName);
		delete iBackup;
		}
	delete iDatabaseName;
	iObservers.Close();
	}

void CLogServBackupManager::ConstructL()
	{
	CTimer::ConstructL();
	}

CLogServBackupManager* CLogServBackupManager::NewL(TInt aPriority)
	{
	CLogServBackupManager* self = new(ELeave) CLogServBackupManager(aPriority);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServBackupManager::BIObserverAddL(MLogServBackupObserver& aObserver, TLogServBackupPriority aPriority)
	{
	LOGTEXT2("CLogServBackupManager::BIObserverAddL(aPriority=%d)", aPriority);
	TLogBackupNotificationEntry entry(aObserver, aPriority);
	
	// Create orderer which ensures that we place the objects in priority ascending order (i.e. 
	// higher priority gets notified first).
	TLinearOrder<TLogBackupNotificationEntry> orderer(CompareEntries);
	const TInt error = iObservers.InsertInOrderAllowRepeats(entry, orderer);
	User::LeaveIfError(error);

	LOGTEXT("CLogServBackupManager::BIObserverAddL() - end");
	}

void CLogServBackupManager::BIObserverRemove(MLogServBackupObserver& aObserver)
//
//	Removes an observer from the notification queue
//
	{
	const TInt count = iObservers.Count();
	for(TInt i=0; i<count; i++)
		{
		const TLogBackupNotificationEntry& entry = iObservers[i];
		if	(&aObserver == &entry.iObserver)
			{
			iObservers.Remove(i);
			return;
			}
		}
	}

MLogServBackupInterface::TLogServBackupState CLogServBackupManager::BIState() const
	{
	return iState;
	}

TInt CLogServBackupManager::BIErrorValueForCurrentState() const
	{
	TInt error = KErrNone;
	switch(BIState())
		{
	case ELogServBackupStateIdle:
		error = KErrNone;
		break;
	case ELogServBackupStateBackupInProgress:
		error = KErrAccessDenied;
		break;
		}
	//
	LOGTEXT2("CLogServBackupManager::BIErrorValueForCurrentState() = %d", error);
	return error;
	}

void CLogServBackupManager::BISetDatabaseNameL(const TDesC& aDatabaseName)
	{
#ifdef LOGGING_ENABLED
	LOGTEXT3("CLogServBackupManager::BISetDatabaseNameL(%S, isActive: %d)", &aDatabaseName, IsActive());
	if	(iDatabaseName)
		{
		LOGTEXT2("CLogServBackupManager::BISetDatabaseNameL() - currently registered database filename is: %S", iDatabaseName);
		}
	else
		{
		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - no file registered with backup interface yet");
		}
#endif

	Cancel();

	HBufC* databaseName = aDatabaseName.AllocLC();

	// If we haven't already created a backup observer, then we need
	// to kick the object back into life again.
	if	(!iBackup)
		{
		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - no backup session created");

		// Try and create backup interface synchronously first of all, if that fails
		// then construct as an idle operation
		TRAPD(err, iBackup = CreateBackupL(*databaseName));

		LOGTEXT2("CLogServBackupManager::BISetDatabaseNameL() - backup session creation error: %d", err);
		if	(err != KErrNone)
			After(0);
		}
	else if (iDatabaseName->Compare(aDatabaseName) != KErrNone)
		{
		LOGTEXT3("CLogServBackupManager::BISetDatabaseNameL() - database filename changed from %S to %S", &iDatabaseName, &aDatabaseName);

		// De register the old, register the new
		iBackup->DeregisterFile(*iDatabaseName);
		iBackup->RegisterFileL(aDatabaseName, *this);

		LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - database re-registration complete");
		}


	delete iDatabaseName;
	iDatabaseName = databaseName;
	CleanupStack::Pop(databaseName);

	LOGTEXT("CLogServBackupManager::BISetDatabaseNameL() - end");
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

void CLogServBackupManager::RunL()
//
// This method does two things
//
// 1) Keeps trying to create a backup object - which may fail on device 
//    bootup until the ui framework starts the backup server.
//
// 2) Handles the case where the server fails to restart correctly after a backup - it keeps trying
//
	{
	LOGTEXT2("CLogServBackupManager::RunL(%d)", iStatus.Int());

	if	(!iBackup)
		{
		LOGTEXT("CLogServBackupManager::RunL() - trying to create backup object");

		// Keep trying to create backup object
		iBackup = CreateBackupL(*iDatabaseName);

		LOGTEXT("CLogServBackupManager::RunL() - backup object created okay");
		}
	else
		{
		// This branch is executed if we failed to create the backup object on our first
		// attempt in BISetDatabaseNameL
		LOGTEXT("CLogServBackupManager::RunL() - notifying observers about dummy backup ended event");
		NotifyObservers(MLogServBackupObserver::EBackupEnded);
		}

	LOGTEXT("CLogServBackupManager::RunL() - end");
	}

TInt CLogServBackupManager::RunError(TInt aError)
	{
	(void) aError;
	LOGTEXT2("CLogServBackupManager::RunError(%d)", aError);

	// Make sure we don't leak anything, pretend the backup started again - won't fail
	if	(iBackup)
		NotifyObservers(MLogServBackupObserver::EBackupStarting);

	After(KTimerDelay);

	LOGTEXT("CLogServBackupManager::RunError() - end");
	return KErrNone;
	}

TInt CLogServBackupManager::NotifyObservers(MLogServBackupObserver::TLogServBackupEvent aEvent)
//
//	Notify observers of the event. Assumes event queue correctly ordered.
//
	{
	const TInt count = iObservers.Count();
	LOGTEXT3("CLogServBackupManager::NotifyObservers(aEvent = %d) - %d observers", aEvent, count);

	// Depending on the event type, we have to reverse the order of notification.
	// I wish it was possible to do this in a more elegant way... hmm... pointers
	// to member functions?...

	TInt error = KErrNone;
	TRAP(error, 
		//
		switch(aEvent)
			{
		case MLogServBackupObserver::EBackupStarting:
			{
			// Update our state
			iState = ELogServBackupStateBackupInProgress;

			// Notify
			for(TInt i=0; i<count; i++)
				{
				TLogBackupNotificationEntry& entry = iObservers[i];
				entry.iObserver.BOHandleEventL(aEvent);
				}
			}
			break;
		case MLogServBackupObserver::EBackupEnded:
			{
			// Update our state
			iState = ELogServBackupStateIdle;

			// Notify
			for(TInt i=count-1; i>=0; i--)
				{
				TLogBackupNotificationEntry& entry = iObservers[i];
				entry.iObserver.BOHandleEventL(aEvent);
				}
			}
			break;
			}
		);

	LOGTEXT("CLogServBackupManager::NotifyObservers() - end");
	return error;
	}

void CLogServBackupManager::ChangeFileLockL(const TDesC& aFileName, TFileLockFlags aFlags)
	{
	LOGTEXT3("CLogServBackupManager::ChangeFileLockL(%S, aFlags = %d)", &aFileName, aFlags);

#ifdef LOGGING_ENABLED
	if	(aFlags & (MBackupObserver::EReleaseLockReadOnly | MBackupObserver::EReleaseLockNoAccess))
		{
		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Backup is STARTING");
		}
	else
		{
		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Backup is ENDING");
		}
#endif

	Cancel();

	// This probably won't ever happen
	if	(iDatabaseName->Compare(aFileName) != 0)
		{
		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Notification from backup server about the wrong file!");
		User::Leave(KErrNotFound);
		}

	// Work out type of backup event
	MLogServBackupObserver::TLogServBackupEvent event = MLogServBackupObserver::EBackupEnded;
	if	(aFlags & (MBackupObserver::EReleaseLockReadOnly | MBackupObserver::EReleaseLockNoAccess))
		event = MLogServBackupObserver::EBackupStarting;

	// Notify observers
	const TInt error = NotifyObservers(event);
	LOGTEXT2("CLogServBackupManager::ChangeFileLockL() - notifying observers error: %d", error);

	// Shouldn't be any problems when notifying observers
	__ASSERT_DEBUG(!(event == MLogServBackupObserver::EBackupStarting && error != KErrNone), Panic(ELogStartBackupFailure));

	// Handle failure to restart the server after a backup
	if	(error && (event == MLogServBackupObserver::EBackupEnded))
		{
		LOGTEXT("CLogServBackupManager::ChangeFileLockL() - Kicking off server objects again after backup completed (and there was an error)");

		// Make sure we don't leak anything, pretend the backup started again - won't fail
		Cancel();
		NotifyObservers(MLogServBackupObserver::EBackupStarting);
		After(KTimerDelay);
		}

	LOGTEXT("CLogServBackupManager::ChangeFileLockL() - end");
	}

CBaBackupSessionWrapper* CLogServBackupManager::CreateBackupL(const TDesC& aLogDatabaseFileName)
	{
	LOGTEXT("CLogServBackupManager::CreateBackupL()");

	// Create backup session
	CBaBackupSessionWrapper* backup = CBaBackupSessionWrapper::NewL();
	CleanupStack::PushL(backup);

	// Register with the backup server
	backup->RegisterFileL(aLogDatabaseFileName, *this);

	// All done
	CleanupStack::Pop(backup);

	LOGTEXT("CLogServBackupManager::CreateBackupL() - end");
	return backup;
	}

TInt CLogServBackupManager::CompareEntries(const TLogBackupNotificationEntry& aLeft, const TLogBackupNotificationEntry& aRight)
	{
	if	(aLeft.iPriority == aRight.iPriority)
		return 0;
	else if (aLeft.iPriority > aRight.iPriority) // Not what you might expect since higher priority must go first
		return -1;
	return 1;
	}