// Copyright (c) 2006-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:
//
 
#ifndef SRVREPOS_H
#define SRVREPOS_H

#include <e32base.h>
#include <s32file.h>
#ifdef SYMBIAN_BAFL_SYSUTIL
#include <bafl/sysutil.h>
#endif
#include "shrepos.h"
#include "setting.h"
#include "clientrequest.h"
#include "sessnotf.h"
#include "operations.h"
#include "datatype.h"

class MObserver;
class CRestoredRepository;

class CServerRepository : public CRepositoryTransactor, public MOperationLogic
	{
public:
	void OpenL(TUid aUid, MObserver& aObserver, TBool aFailIfNotFound = ETrue);
	void HandleOpenMergeL();
	void Close();
	void RestoreNotify(const CRestoredRepository& aRstRepos);
	TInt RFSRepositoryL();
#ifdef SYMBIAN_BAFL_SYSUTIL
	static void CheckROMReflashL();
#endif
	static void RFSAllRepositoriesL();

	inline TInt StartTransaction(TInt aMode)
		{
		return iRepository->StartTransaction(*this, aMode);
		}
	inline TInt CommitTransaction(TUint32& aKeyInfo)
		{
		return iRepository->CommitTransaction(*this, aKeyInfo);
		}
	inline void CancelTransaction() // serves as both rollback and async cancel
		{
		TServerResources::iObserver->CancelTransaction(*this,iUid);
		}
	void CleanupCancelTransactionPushL();
	inline TInt FailTransaction(TInt aError, TUint32 aErrorKey)
		{
		// returns aError to allow "return FailTransaction(error, errorKey);" - error written once
		return iRepository->FailTransaction(*this, aError, aErrorKey);
		}

	inline void FailAllTransactions()
		{
		iRepository->FailAllTransactions(NULL);
		}
	/** must currently be in active Read transaction. Does not fail
	transaction here if promotion to read/write failed.
	@return KErrNone if promoted, KErrLocked if not
	*/
	inline TInt AttemptPromoteTransactionToReadWrite()
		{
		ASSERT(IsInActiveReadTransaction());
		return iRepository->AttemptPromoteTransactionToReadWrite(*this);
		}

	inline TServerSetting* GetPersistentSetting(TUint32 aId)
		{
		return iRepository->GetSettings().Find(aId);
		}
	inline TServerSetting* GetTransactionSetting(TUint32 aId)
		{
		return iTransactionSettings.Find(aId);
		}

	template <class T> 
	TInt TransactionCreateL(TUint32 aKey, const T& aVal, TUint32* aMeta);

	template <class T>
	TInt TransactionSetL(TUint32 aKey, const T& aVal);

	inline TInt TransactionDeleteL(TUint32 aId)
		{
		// all write operations now done in a transaction
		ASSERT(IsInActiveReadWriteTransaction());
		TRAPD(err,DeleteSettingL(aId));
		if (err==KErrNoMemory)
			User::LeaveNoMemory();
		return err;
		}
		
	TInt TransactionMoveL(const TClientRequest& aMessage, TUint32& aErrorKey);
	TInt TransactionDeleteRangeL(const TClientRequest& aMessage, TUint32& aErrId);

	TInt CheckPermissions(RSettingPointerArray& aSettings, const TClientRequest& aMessage, const char* aDiagnostic,TBool aReadPolicy,TUint32& aErrId);
	
	TInt CheckAccessPolicyBeforeMoving(const TClientRequest& aMessage, const TServerSetting& aSourceSetting, TUint32 aSourceKey, 
							const TServerSetting& aTargetSetting, TUint32 aTargetKey, TUint32& aErrorKey);
								
	TInt CheckMovePermissions(const RSettingPointerArray& aSourceSettings,const TClientRequest& aMessage,TUint aSourceToTarget,TUint32& aErrorKey)
		{
		TInt error=KErrNone;
		for (TInt i=0;i<aSourceSettings.Count() && error==KErrNone;i++)	
			{
			ASSERT(aSourceSettings[i]);
			TServerSetting* sourceSetting = aSourceSettings[i];
			TUint32 sourceKey = sourceSetting->Key();
			TUint32 targetKey = sourceKey ^ aSourceToTarget;
			TServerSetting* targetSetting = GetSetting(targetKey);
		
			error = CheckAccessPolicyBeforeMoving(aMessage, *sourceSetting, sourceKey, *targetSetting, targetKey, aErrorKey);		
			}
		return error;
		}

	inline TInt FindPersistentSettings(TUint32 aPartialId, TUint32 aIdMask, RSettingPointerArray& aMatches) const
		{
		// guarantees to reset RSettingPointerArray in case of error
		return iRepository->GetSettings().Find(aPartialId, aIdMask, aMatches);
		}
	inline TInt FindTransactionSettings(TUint32 aPartialId, TUint32 aIdMask, RSettingPointerArray& aMatches) const
		{
		// guarantees to reset RSettingPointerArray in case of error
		return iTransactionSettings.Find(aPartialId, aIdMask, aMatches);
		}

	inline void CommitChangesL(TCentRepLocation aLocation = EPersists) const
		{
		iRepository->CommitChangesL(aLocation);
		}

	TInt ResetL(TUint32 aId);
	TInt ResetAllL();

	inline const TSecurityPolicy& GetReadAccessPolicy(const TServerSetting& aSetting) const
		{
		return iRepository->GetReadAccessPolicy(aSetting);
		}
	inline const TSecurityPolicy& GetReadAccessPolicy(TUint32 aId) const
		{
		return iRepository->GetReadAccessPolicy(aId);
		}
	inline const TSecurityPolicy& GetDefaultReadAccessPolicy() const
		{
		return iRepository->GetDefaultReadAccessPolicy();
		}

	inline const TSecurityPolicy& GetFallbackWriteAccessPolicy(TUint32 aId) const
		{
		return iRepository->GetFallbackWriteAccessPolicy(aId);
		}

	inline const TSecurityPolicy& GetWriteAccessPolicy(const TServerSetting& aSetting) const
		{
		return iRepository->GetWriteAccessPolicy(aSetting);
		}
	inline const TSecurityPolicy& GetWriteAccessPolicy(TUint32 aId) const
		{
		return iRepository->GetWriteAccessPolicy(aId);
		}
	inline const TSecurityPolicy& GetDefaultWriteAccessPolicy() const
		{
		return iRepository->GetDefaultWriteAccessPolicy();
		}

	void HandleSWIUpdateL(TUid aUid, TTime aModified, CSessionNotifier& aNotifier);
	void HandleSWIDeleteL(TUid aUid, CSessionNotifier& aNotifier);

	void StoreRepositoryContentsL(CStreamStore & aStore, TStreamId & aSettingStreamId, TStreamId & aDeletedSettingsStreamId) const;
	void StoreRepositorySettingValuesL(CStreamStore& aStore, TStreamId & aSettingStreamId) const;	
	void RestoreRepositoryContentsL(CStreamStore& aStore, TStreamId aSettingStreamId, TStreamId aDeletedSettingsStreamId, CRestoredRepository& aRstRepos);
	void RestoreRepositorySettingValuesL(CStreamStore& aStore, TStreamId aSettingStreamId, CRestoredRepository& aRstRepos);

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS
	void ResetFromIniFileL(TUint32 aId,CIniFileIn::TIniFileOpenMode aIniFileOpenMode,TBool& aKeyFound);
#else	
	void ResetFromIniFileL(TUint32 aId,TCentRepLocation aLocation,TBool& aKeyFound);
#endif	
	
	void LoadIniRepL(CIniFileIn::TIniFileOpenMode aMode);
	TBool GetMetaFromIni(TUint32 aKey, TUint32& aMeta);
	
	void RestoreInstallRepositoryL(TUid aUid, CStreamStore& aStore, TStreamId& aSettingStreamId, CRestoredRepository& aRstRepos); 
	void BackupInstallRepositoryL(TUid aUid, CStreamStore& aStore, TStreamId& aSettingStreamId); 


#ifdef CACHE_OOM_TESTABILITY
	TInt SizeiRepository()
		{
		return iRepository->Size();
		}
#endif	
	
	inline MObserver* Notifier()
		{
		ASSERT(iNotifier);
		return iNotifier;
		}
	
	inline void AccessRepositoryL()
		{
		iRepository = TServerResources::iObserver->AccessL(iUid);
		}

private:
	enum TPersistedRepActions {ECenRepReflash,ECenRepReset};
	
private:
	static void ProcessPersistsRepositoriesL(TPersistedRepActions aRomFlashOrReset);
	static void CacheRomVersionL(const TDesC& aFilename, TDesC8& aVersion);
	TInt HandleReflashofRepositoryL();

	//--------------------virtual functions from MOperation----------------------------
public:
	void GetSingleMeta(TUint aKey,TUint32& aMeta)
		{
		TUint32 metaFromIni;
		if (GetMetaFromIni(aKey, metaFromIni))
			{
			aMeta=~KMetaDefaultValue & metaFromIni;
			}
		else
			{
			//First check for a matching "range" default
			TSettingsDefaultMeta* defaultMeta = iRepository->iSimRep->RangeMetaArray().Find(aKey);
			if (defaultMeta)
				{
				aMeta=defaultMeta->GetDefaultMetadata();
				}
			else
				{
				// Range value not found, try for a repository default
				aMeta=iRepository->iSimRep->DefaultMeta();
				}			
			}		
		}
		
	TSettingsAccessPolicy* GetFallbackAccessPolicy(TUint32 aId) const
		{
		return iRepository->GetFallbackAccessPolicy(aId);		
		}	

	RSettingsArray& GetWritableSettingList()
		{
		return iTransactionSettings;
		}

	TServerSetting* GetSetting(TUint aKey)
		{
		// try to be most efficient when no transaction changes
		if ((iTransactionSettings.Count() > 0) && IsInActiveReadWriteTransaction())
			{
			TServerSetting* s = GetTransactionSetting(aKey);
			if (s)
				{
				return (s);
				}
			}
		return GetPersistentSetting(aKey);
		}

	/** Returns pointer array of settings whose keys match the partial key and mask. Combines
	settings from the persistent list with those in the transaction, with priority given to the
	latter, including settings flagged as deleted eliminating the corresponding entry from the 
	persistent settings (plus themselves so the final list has no settings flagged as deleted in it).
	Can also call this method when not in a transaction.
	In case of error, aMatches may contain entries and must be Reset.
	*/
	TInt FindSettings(TUint32 aSourcePartialKey,TUint32 aMask,RSettingPointerArray& aOutputArray) const
		{
		TInt error = FindPersistentSettings(aSourcePartialKey, aMask, aOutputArray);
		// try to be most efficient when no transaction changes
		if ((iTransactionSettings.Count() > 0) && IsInActiveReadWriteTransaction() && (KErrNone == error))
			{
			RSettingPointerArray transactionSettings;
			error = FindTransactionSettings(aSourcePartialKey, aMask, transactionSettings);
			if (error == KErrNone)
				{
				error = RSettingsArray::Merge(aOutputArray, transactionSettings);
				}
			transactionSettings.Reset();
			}
		return error;
		}
	
	//---------------------end of virtual functions-------------------------------------------	
#ifndef FOTA_UNIT_TESTING
private:
#endif
	CSharedRepository* iRepository;
	MObserver* iNotifier;	
	TUid iUid;
	};

template <class T>
TInt CServerRepository::TransactionSetL(TUint32 aKey, const T& aVal)
	{
	// all write operations now done in a transaction
	ASSERT(IsInActiveReadWriteTransaction());
	
	TRAPD(error,SetSettingL(aKey,aVal));
	if (error != KErrNone)
		{
		FailTransaction(error, aKey);
		}
	return error;
	}
	

template <class T>
TInt CServerRepository::TransactionCreateL(TUint32 aKey, const T& aVal, TUint32* aMeta)
	{
	// all write operations now done in a transaction
	ASSERT(IsInActiveReadWriteTransaction());
	
	TRAPD(err,CreateSettingL(aKey,aVal,aMeta));
	if (err==KErrAlreadyExists)
		{
		return FailTransaction(KErrAlreadyExists,aKey);
		}
	User::LeaveIfError(err);
	
	return KErrNone;
	}

#endif // SRVREPOS_H