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

/**
 @file
*/

#include "burstate.h"
#include <babackup.h>
#include "featmgrdebug.h"
#include "featmgrserver.h"

CBurState::CBurState()
	{
	return;
	}

/**
 * The Backup and Restore state machine.
 * This state machine has two state tables. The first table defines the correct modes of operation
 * and the second describe the pathways arrising from error conditions. By seperating the normal
 * pathways from the error pathways we can simplify the state machine into two parts. The function 
 * SetUpBurStruct() will define the pathways for both these tables.
 * Each table has three items per row: a current state, an ending state, and a pointer to a function 
 * that transforms between these two states safely. 
 * Given that we already know where we are, and where we are told to goto, the state machine
 * function BUR_StateMachine() will search the normal operation table for a match, and then apply
 * the function through the pointer. If no match is found, then the goto state is set to Error, and
 * the error table is searched and applied. Because all the state are covered within the error table
 * we can always return to a normal more of operation through the application of the error
 * functions.
 */ 
CBurState::CBurState(CFeatMgrServer* aServer) : iCurrentBURStatus( EFeatMgrBURState_None ), iServer( aServer )
	{
	SetUpBurStruct();
	return;
	}

CBurState::~CBurState()
	{
	return;
	}

CBurState* CBurState::NewLC()
	{
	CBurState* self = new (ELeave)CBurState();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

CBurState* CBurState::NewL()
	{
	CBurState* self=CBurState::NewLC();
	CleanupStack::Pop(); // self;
	return self;
	}

void CBurState::ConstructL()
	{
	return;
	}

/**
 * This function checks the arguments that are passed into HandleBackupOperationEventL. 
 * The TBackupOperationAttributes are checked against known values and an error is returned if
 * the Feature Manager doesn't recognise the events.
 */ 
TInt CBurState::CheckBURArguments(  const TBackupOperationAttributes& aBackupOperationAttributes )
	{
	TInt error( KErrNone );
    iBURLockFlag = aBackupOperationAttributes.iFileFlag;
    iBUROpType   = aBackupOperationAttributes.iOperation;
    
	// determine the operation type (backup or restore)
	switch( iBURLockFlag )	
		{
		case MBackupObserver::EReleaseLockReadOnly:
			INFO_LOG( "MBackupObserver::EReleaseLockReadOnly" );
			break;
		case MBackupObserver::EReleaseLockNoAccess:
			INFO_LOG( "MBackupObserver::EReleaseLockNoAccess" );
			break;
		case MBackupObserver::ETakeLock:
			INFO_LOG( "MBackupObserver::ETakeLock" );
			break;
		default:
			INFO_LOG( "CheckBURArguments iBURLockFlag default" );
			error = KErrNotFound;
			break;
		}
		
	// determine the operation status (e.g. starting, ending)
	switch( iBUROpType )
		{
		case MBackupOperationObserver::ENone:
			INFO_LOG( "ENone" );
			break;
		case MBackupOperationObserver::EStart:
			INFO_LOG( "EStart" );
			break;
		case MBackupOperationObserver::EEnd:
			INFO_LOG( "EEnd" );
			break;
		case MBackupOperationObserver::EAbort:
			INFO_LOG( "EAbort" );	
			break;
		default:
			INFO_LOG( "CheckBURArguments iOperation default" );	
			error = KErrNotFound;
			break;
		}

	return error;
	}

/**
 * Sets up the array entries for the possible backup/restore state vectors. 
 *               from           -> to             : function
 * State vector: None           -> BackupStarted  : Goto_StartBackupState
 * State vector: BackupStarted  -> BackupEnded    : EndBackupState
 * State vector: BackupEnded    -> None           : Goto_NormalState
 * State vector: None           -> RestoreStarted : Goto_StartRestoreState
 * State vector: RestoreStarted -> RestoreEnded   : Goto_EndRestoreState
 * State vector: RestoreEnded   -> None           : Goto_NormalState
 */
void CBurState::SetUpBurStruct()
	{
	BURStruct bStruct;

	// Backup states

	// State vector: None -> BackupStarted : Goto_StartBackupState
	bStruct.iCurrent = EFeatMgrBURState_None;
	bStruct.iGoto = EFeatMgrBURState_BackupStarted;
	bStruct.iFunc = &CFeatMgrServer::Goto_StartBackupState;
	iBURStructArray[0] = bStruct;

	// State vector: BackupStarted -> BackupEnded : EndBackupState
	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
	bStruct.iGoto = EFeatMgrBURState_BackupEnded;
	bStruct.iFunc = &CFeatMgrServer::Goto_EndBackupState;
	iBURStructArray[1] = bStruct;

	// State vector: BackupEnded -> None : Goto_NormalState
	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
	bStruct.iGoto = EFeatMgrBURState_None;
	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
	iBURStructArray[2] = bStruct;

	// Valid restore states
	
	// State vector: None -> RestoreStarted : Goto_StartRestoreState
	bStruct.iCurrent = EFeatMgrBURState_None;
	bStruct.iGoto = EFeatMgrBURState_RestoreStarted;
	bStruct.iFunc = &CFeatMgrServer::Goto_StartRestoreState;
	iBURStructArray[3] = bStruct;

	// State vector: RestoreStarted -> RestoreEnded : Goto_EndRestoreState
	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
	bStruct.iGoto = EFeatMgrBURState_RestoreEnded;
	bStruct.iFunc = &CFeatMgrServer::Goto_EndRestoreState;
	iBURStructArray[4] = bStruct;

	// State vector: RestoreEnded -> None : Goto_NormalState
	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
	bStruct.iGoto = EFeatMgrBURState_None;
	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
	iBURStructArray[6] = bStruct;

	// State vector: None -> None : Goto_NormalState
	bStruct.iCurrent = EFeatMgrBURState_None;
	bStruct.iGoto = EFeatMgrBURState_None;
	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
	iBURStructArray[5] = bStruct;

	
	//
	// Error states

	// State vector: RestoreStarted -> Error : Goto_ErrorState
	bStruct.iCurrent = EFeatMgrBURState_RestoreStarted;
	bStruct.iGoto = EFeatMgrBURState_Error;
	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
	iBURStructErrorArray[0] = bStruct;

	// State vector: RestoreEnded -> Error : Goto_ErrorState
	bStruct.iCurrent = EFeatMgrBURState_RestoreEnded;
	bStruct.iGoto = EFeatMgrBURState_Error;
	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
	iBURStructErrorArray[1] = bStruct;

	// State vector: BackupStarted -> None : Goto_ErrorState
	bStruct.iCurrent = EFeatMgrBURState_BackupStarted;
	bStruct.iGoto = EFeatMgrBURState_Error;
	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
	iBURStructErrorArray[2] = bStruct;
	
	// State vector: BackupEnded -> None : Goto_ErrorState
	bStruct.iCurrent = EFeatMgrBURState_BackupEnded;
	bStruct.iGoto = EFeatMgrBURState_Error;
	bStruct.iFunc = &CFeatMgrServer::Goto_ErrorState;
	iBURStructErrorArray[3] = bStruct;
	
	// State vector: Error -> None : Goto_NormalState
	bStruct.iCurrent = EFeatMgrBURState_Error;
	bStruct.iGoto = EFeatMgrBURState_None;
	bStruct.iFunc = &CFeatMgrServer::Goto_NormalState;
	iBURStructErrorArray[4] = bStruct;
	
	return;
	}

/**
 * Convert from the type provided in TBackupOperationAttributes into more sensible BUR types that
 * can be handles by the BUR_StateMachine. This step is necessary for two reasons, the first is
 * simplification and the second is a lexical check for invalid type MBackupObserver::TFileLockFlags.
 */
BURStatus CBurState::ConvertToBURState(  const TBackupOperationAttributes& aBackupOperationAttributes )
	{
	BURStatus status = EFeatMgrBURState_Error;
    iBURLockFlag = aBackupOperationAttributes.iFileFlag;
    iBUROpType   = aBackupOperationAttributes.iOperation;
	// we ignore the iOperation state
    
	if( iBURLockFlag == MBackupObserver::ETakeLock )
		{
		// ending (this doesn't define whether it was a backup
		// or a restore ending, just that file writing can now start 
		// again).
		INFO_LOG("ChangeFileLockL() BUR ending");
		switch( iCurrentBURStatus )
			{
			case( EFeatMgrBURState_BackupStarted ):
				status = EFeatMgrBURState_BackupEnded;
				break;
			case( EFeatMgrBURState_RestoreStarted ):
				status = EFeatMgrBURState_RestoreEnded;
				break;
			case( EFeatMgrBURState_None ):
				status = EFeatMgrBURState_None;
				break;
			default:
				status = EFeatMgrBURState_Error;
				break;
			}
		}
	else if( (iBURLockFlag & MBackupObserver::EReleaseLockReadOnly) &&
		(iBURLockFlag & ~MBackupObserver::EReleaseLockNoAccess) )
		{
		// starting (making the file read-only is a sign that we are
		// in "backup" mode).
		INFO_LOG("ChangeFileLockL() backup starting");
		status = EFeatMgrBURState_BackupStarted;
		}
	else if( iBURLockFlag & MBackupObserver::EReleaseLockNoAccess )
		{
		// starting (now read/write access is used to signify that a
		// restore has been started).
		INFO_LOG("ChangeFileLockL() restore starting");
		status = EFeatMgrBURState_RestoreStarted;
		}
	else
		{
		// unhandled flag states
		INFO_LOG("ChangeFileLockL() error state");
		status = EFeatMgrBURState_Error;
		}
	
	return status;
	}

/**
 * This function is called from within featmgr server when a backup event occurs
 * There are two state variables coming into Feature Manager as types MBackupObserver::TFileLockFlags 
 * and TOperationType. Only certain combinations of these two state variables are valid for Feature
 * Manager and if the combination is not valid (because there is no way of returning an error) 
 * it will just set the internal state machine into an "error" state.
 * Given our current state and our goto state (i.e. where we are at the moment and where we want to goto)
 * the state machine checks that this is a valid path in our state machine and then perform the correct 
 * operations to get us to the next valid state.
 */
void CBurState::BUROperationL( const TBackupOperationAttributes& aBackupOperationAttributes )
	{
	BURStatus gotoState    = EFeatMgrBURState_Error;  // fail safe
	BURStatus currentState = iCurrentBURStatus;       // where in the state machine we are at the moment
	
	// Check that the arguments are within valid limits
	if( KErrNone == CheckBURArguments( aBackupOperationAttributes ) )
		{
		// Now convert into states that the Feature Manager understands.
		gotoState = ConvertToBURState( aBackupOperationAttributes );
		}
	
	// Check that this is a valid path and then perform the correct operations to get to the next valid state
	iCurrentBURStatus = BUR_StateMachine( currentState, gotoState );
	
	return;
	}

/**
 * The state machine for the backup and restore of the featmgr 
 * The logic that goes into changing states in the state machine.
 */
BURStatus CBurState::BUR_StateMachine( BURStatus aCurrent, BURStatus aGoto )
	{
	TInt count = 0;
	TBool found = EFalse;

	// Fail safe default state values
	BURStatus newState			= EFeatMgrBURState_Error;
	BURStatus stateTableGoto    = EFeatMgrBURState_Error;
	BURStatus stateTableCurrent = EFeatMgrBURState_Error;
	
	// Normal operation
	//
	do
		{
		// Get the n-th state table [current,goto] state vector
		stateTableCurrent = iBURStructArray[count].iCurrent;
		stateTableGoto    = iBURStructArray[count].iGoto;
		
		// if the state table matches what we are given
		if( (aCurrent == stateTableCurrent) && 
			(aGoto    == stateTableGoto) )
			{
			// process the relevant state function
			if( NULL != iBURStructArray[count].iFunc )
				{
				newState = (iServer->*iBURStructArray[count].iFunc)( aCurrent );

				// check result: when from the state machine is not what we expected from the state table
				if( newState != stateTableGoto )
					{
					// put state machine into an error state and break "normal" loop
					aCurrent = newState;
					aGoto    = EFeatMgrBURState_Error;
					break;
					}
				else
					{
					found = ETrue;
					}
				}
			
			// self-perpetuate in certain cases
			if( (EFeatMgrBURState_BackupEnded == newState) || 
				(EFeatMgrBURState_RestoreEnded == newState) )
				{
				aCurrent = newState;
				aGoto = EFeatMgrBURState_None;
				found = EFalse;
				count = 0;
				}
			}
		count++;
		}
	while( (!found) && count < KBURArrayLength );
	

	// Error recovery
	//
	if( EFeatMgrBURState_Error == aGoto ||
		EFalse == found )
		{
		// reset 
		aGoto = EFeatMgrBURState_Error;
		count = 0;
		found = EFalse;

		do
			{
			// Get the n-th state table [current,goto] state vector in the error array
			stateTableCurrent = iBURStructErrorArray[count].iCurrent;
			stateTableGoto    = iBURStructErrorArray[count].iGoto;
			
			// if the state table matches what we are given
			if( ((aCurrent == stateTableCurrent) && (aGoto == stateTableGoto))  )
				{
				// process the relevant state function
				if( NULL != iBURStructErrorArray[count].iFunc )
					{
					newState = (iServer->*iBURStructErrorArray[count].iFunc)( aCurrent );
					// there is no error recovery from error recovery.
					found = ETrue;
					}
				
				// self-perpetuate in certain cases
				if( EFeatMgrBURState_Error == newState )
					{
					aCurrent = newState;
					aGoto = EFeatMgrBURState_None;
					found = EFalse;
					count = 0;
					}
				}
			count++;
			}
		while( (!found) && count < KBURErrorArrayLength );
		
		}
	
	return newState;
	}