// 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:
//

#ifndef OPERATIONS_H
#define OPERATIONS_H

#include <e32debug.h>
#include <e32std.h>
#include "datatype.h"

/**
This class encapsulates the operation logic used in both the client-server and the PC side library. The MOperationLogic
defines a set of pure virtual functions to be implemented. Currently the two classes responsible for performing operations
respectively are the CServerRepository and the CPcRepImpl
@internalTechnology
*/
class MOperationLogic
	{
	public:

/** DELETE RANGE
Delete a settings from a source list. Settings are marked as deleted rather than deleted immediately
@param aSourceList the source array of settings's pointer matching the partial key and mask
@param aPartialKey the partialKey of the settings to be delted
@param aErrorKey to hold the error encountered during the Delete operation
*/
void DeleteSettingsRangeL(RSettingPointerArray& aSourceList,TUint32 aPartialKey,TUint32& aErrorKey)
	{
	if (aSourceList.Count()==0)	
		{
		aErrorKey=aPartialKey;		
		User::Leave(KErrNotFound);
		}
		
	aErrorKey = KUnspecifiedKey;
	TInt numSettings = aSourceList.Count();
	TInt error=KErrNone;		
	for (TInt i = 0; (i < numSettings) && (error == KErrNone); i++)
		{
		ASSERT(aSourceList[i]);
		TServerSetting& settingToDelete = *(aSourceList[i]);
		TUint32 key = settingToDelete.Key();
		// delete it Ensure there is a delete placeholder at the location
		if (GetWritableSettingList().Find(key) == &settingToDelete)
			{
			// we are deleting a setting that is already in the transaction list: Flag it as deleted
			settingToDelete.Reset();
			settingToDelete.SetDeleted();
			}
		else
			{
			// create a new placeholder and set as deleted
			TServerSetting newSetting(key);
			newSetting.SetMeta(settingToDelete.Meta());
			newSetting.SetDeleted();
			GetWritableSettingList().OrderedInsertL(newSetting);
			}
		}	
	}

/** DELETE
Mark a setting in the source list as deleted if found
@param aId the setting Id to be deleted
@param aSettingList the list of source setting to look for
*/
void DeleteSettingL(TUint32 aId)
	{
	TServerSetting* ts=GetWritableSettingList().Find(aId);
	if (ts)
		{
		if (ts->IsDeleted())
			User::Leave(KErrNotFound);
		else
			{
			ts->Reset();
			ts->SetDeleted();	
			}
		}
	else
		{
		TServerSetting* s=GetSetting(aId);
		if (!s)	
			User::Leave(KErrNotFound);
		else
			{
			TServerSetting newSetting(aId);
			newSetting.SetMeta(s->Meta());
			newSetting.SetDeleted();
			GetWritableSettingList().OrderedInsertL(newSetting);
			}
		}
	}

/** SET
Set a setting to a new value, create the setting if it does not exist yet
@param aKey the id of the setting
@param aVal the new value of the setting
*/
template <class T>
void SetSettingL(TUint32 aKey,const T& aVal)
	{
	TServerSetting* s = GetWritableSettingList().Find(aKey);
	if (s)
		{
		if (s->IsDeleted())
			{
	 		// replace the deleted entry with the new values
			s->CopyValueL(aVal);
			s->SetAccessPolicy(GetFallbackAccessPolicy(aKey)); 			
			}
		else
			{
			User::LeaveIfError(s->AssignValueFrom(aVal));	
			s->SetMeta(s->Meta() & (~KMetaDefaultValue));	
			}		
		}
	else	
		{
		TServerSetting* ns=GetSetting(aKey);
		TServerSetting newSetting(aKey);
		newSetting.CopyValueL(aVal);
		newSetting.SetAccessPolicy(GetFallbackAccessPolicy(aKey));
		TUint32 metadata;		
		if (!ns)
			{
			GetSingleMeta(aKey,metadata);
			}
		else
			{
			if (!ns->IsType(aVal))
				{
				User::Leave(KErrArgument);
				}			
			metadata = ~KMetaDefaultValue & ns->Meta();
			}
		newSetting.SetMeta(metadata);			
		newSetting.PushL(); // only needed for strings
		GetWritableSettingList().OrderedInsertL(newSetting);	
		newSetting.Pop();			
		}
	}

/** CREATE
Create a setting with a new value with a meta value.If meta value
not specified it will attempt to look for the meta in order of single
,range, and finally default meta
@param aKey the id of the setting
@param aVal the new value of the setting
@param aMeta the meta value of the setting
@leave KErrAlreadyExists if setting with that id already exist
*/
template <class T>
void CreateSettingL(TUint32 aKey, const T& aVal, TUint32* aMeta)
	{
	TServerSetting* s = GetSetting(aKey);
	if (s)
		{
		if (!s->IsDeleted())
			User::Leave(KErrAlreadyExists);
		else
			{
			//previously deleted settings			
			s->CopyValueL(aVal);
			s->SetAccessPolicy(GetFallbackAccessPolicy(aKey));		
			}
		}
	else
		{
		//brand new settings, create this
		TServerSetting newSetting(aKey);
		newSetting.CopyValueL(aVal);
		if (aMeta)		
			{
			newSetting.SetMeta(*aMeta);
			}
		else
			{
			TUint32 singleMeta;
			GetSingleMeta(aKey,singleMeta);
			newSetting.SetMeta(singleMeta);	
			}
		newSetting.SetAccessPolicy(GetFallbackAccessPolicy(aKey));
		newSetting.PushL(); // only needed for strings
		GetWritableSettingList().OrderedInsertL(newSetting);	
		newSetting.Pop();		
		}
	}

/** GETMETA
Retrieve the meta associated with a setting
@param aId the id of the setting
@param aMeta return value for the setting's meta
@return KErrNotFound if setting does not exist
*/
TInt GetMeta(TUint32 aId, TUint32& aMeta)
	{
	const TServerSetting* s = GetSetting(aId);
	//if is deleted or cannot be found
	if (s && s->IsDeleted() || !s)
		{
		return KErrNotFound;
		}
	aMeta = ~KMetaDefaultValue & s->Meta();
	return KErrNone;
	}

/** GET
Retrieve the value of a setting
@param aId the id of the setting
@param aVal return value for the setting's value
@return KErrNotFound if setting does not exist
		KErrArgument if specified setting type does not match	
*/
template <class T>
TInt Get(TUint32 aId, T& aVal)
	{
	const TServerSetting* s = GetSetting(aId);
	//if is deleted or cannot be found
	if (s && s->IsDeleted() || !s)
		{
		return KErrNotFound;
		}
	return s->AssignValueTo(aVal);
	}

/** FIND COMPARE
Retrieve a list of settings' id that match the value based on either the equal or not equal comparison
@param aInputArray the source array of pointer to the settings
@param aVal the value to be compared for the setting
@param aEqual the comparison rule to be applied
@param aFoundIds the passed in ID array to hold the matching settings
*/
template <class T>
void FindCompareL(const RSettingPointerArray& aInputArray,const T& aVal,TComparison aEqual,RArray<TUint32>& aFoundIds) const
	{
	aFoundIds.Reset();
	TInt numSettings=aInputArray.Count();
	for (TInt i=0;i< numSettings;i++)
		{
		ASSERT(aInputArray[i]);
		const TServerSetting& setting = *(aInputArray[i]);
		ASSERT(!setting.IsDeleted());
		TInt error=KErrNone;		
		if(aEqual && setting==aVal || !aEqual && setting!=aVal)
			{
			error = aFoundIds.Append(setting.Key());
			if (error != KErrNone)
				{
				aFoundIds.Reset();
				User::Leave(error);
				}
			}
		}
	if (aFoundIds.Count() == 0)
		{
		User::Leave(KErrNotFound);
		}
	}
		
/** FINDL
Retrieve a list of settings that match the partial id and mask
@param aSourcePartialKey the partial key to match
@param aMask the mask to be used with the partial key for matching
@param aFoundIds, the array to hold the found settings id
@param aFoundIdsMaxLimit, specify the max id to fit in the aFoundIds
@param aExcessIds, the array to hold the remaining settings id
*/		
void FindL(TUint32 aSourcePartialKey,TUint32 aMask,RArray<TUint32>& aFoundIds,TUint aFoundIdsMaxLimit,RArray<TUint32>& aExcessIds)
	{
	RSettingPointerArray settings;
	CleanupClosePushL(settings);
	TInt error = FindSettings(aSourcePartialKey,aMask, settings);
	if (error == KErrNone)
		{
		const TUint numSettings = settings.Count();
		if (numSettings==0)
			{
			User::Leave(KErrNotFound);
			}
		aFoundIds.Reset();
		
		const TUint numInitial = numSettings > aFoundIdsMaxLimit ? aFoundIdsMaxLimit : numSettings;
		const TUint numFinal = numSettings > aFoundIdsMaxLimit ? numSettings - aFoundIdsMaxLimit : 0;
		
		//reserve memory for everything that needs to be added to the array
		aFoundIds.ReserveL(numSettings);
		
		//now append up to aFoundIdsMaxLimit settings
		for(TUint i = 0; i < numInitial; i++)
			{
			ASSERT(settings[i]);
			// all settings flagged as deleted should have been removed by now, but just to be safe:
			ASSERT(!settings[i]->IsDeleted());
			aFoundIds.AppendL(settings[i]->Key());
			}
			
		//fill the aExcessIds array with any remaining settings
		if(numFinal)
			{
			aExcessIds.Reset();
			aExcessIds.ReserveL(numFinal);
			for(TUint i = numInitial; i < numSettings; i++)
				{
				ASSERT(settings[i]);
				// all settings flagged as deleted should have been removed by now, but just to be safe:
				ASSERT(!settings[i]->IsDeleted());
				aExcessIds.AppendL(settings[i]->Key());
				}
			}
		}
	CleanupStack::PopAndDestroy();
	User::LeaveIfError(error);
	}

/** MOVE
Move settings that match a given partial key to another target partial key given the mask
@param aSourcePartialKey, the source partialKey
@param aTargetPartialKey the target partialKey
@param aMask the mask to be used with the partial keys
@param aErrorKey to hold the error encountered during the move operation
@param aSourcePointerArray the array containing the source settings' pointer
*/
TInt MoveL(TUint32 aSourcePartialKey,TUint32 aTargetPartialKey,TUint32 aMask, TUint32& aErrorKey,
			const RSettingPointerArray& aSourcePointerArray)
	{
	// all write operations now done in a transaction
	TInt error = KErrNone;
	aErrorKey = KUnspecifiedKey;
	
	TUint32 maskedSourcePartialKey = aSourcePartialKey & aMask;
	TUint32 maskedTargetPartialKey = aTargetPartialKey & aMask;
	TUint32 sourceToTarget = maskedSourcePartialKey ^ maskedTargetPartialKey;
	if(!sourceToTarget)
		{
		// not moving anywhere: must return now as this trivial case fails with later logic
		return KErrNone;
		}

	//Validation of the SourcePointerArray whether any item exist
	if (aSourcePointerArray.Count() == 0)
		{
		aErrorKey=aSourcePartialKey;
		return KErrNotFound;
		}

	// create a local copy of settings as the settings pointed to by RSettingPointerArray 
	// could move and cause CServerRepository to point to the wrong key, added as fix for DEF080104
	RSettingsArray settingsCopy;
	CleanupClosePushL(settingsCopy);
	settingsCopy.CopyFromPointerArrayL(aSourcePointerArray);
			
	for (TInt i = 0; (i < settingsCopy.Count()) && (error == KErrNone); i++)
		{
		ASSERT(&settingsCopy[i]);
		TServerSetting& sourceSetting = settingsCopy[i];
		TUint32 sourceKey = sourceSetting.Key();
		TUint32 targetKey = sourceKey ^ sourceToTarget;
		
		TServerSetting* targetSetting = GetSetting(targetKey);		
		if (targetSetting)
			{
			// must be set as deleted only(for PC side this can never be reached, all setting either exist or not and if exist
			// this will return KErrAlreadyExists and this error already captured earlier
			ASSERT(targetSetting->IsDeleted());
			error = targetSetting->Replace(sourceSetting);
			if (error == KErrNone)
				{
				targetSetting->SetKey(targetKey);
				// setting takes the access policy of the target key
				targetSetting->SetAccessPolicy(GetFallbackAccessPolicy(targetKey));
				}
			}
		else
			{
			TServerSetting newSetting;
			error = newSetting.Replace(sourceSetting);
			if (error == KErrNone)
				{
				TUint32 metaFromIni;
				newSetting.SetKey(targetKey);
				GetSingleMeta(targetKey,metaFromIni);
				newSetting.SetMeta(metaFromIni);
			
				// setting takes the access policy of the target key
				newSetting.SetAccessPolicy(GetFallbackAccessPolicy(targetKey));
				newSetting.PushL(); // only needed for strings
				GetWritableSettingList().OrderedInsertL(newSetting);
				newSetting.Pop();	// only needed for strings
				}
			}
			
		// ensure there is a delete placeholder at the old location
		TServerSetting* oldSetting=GetWritableSettingList().Find(sourceKey);
		if (oldSetting)
			{
			oldSetting->Reset();
			oldSetting->SetDeleted();
			}
		else
			{
			//this part cannot happen for PC side as the search is on the persistent directly
			TServerSetting newSetting(sourceKey);
			newSetting.SetDeleted();
			GetWritableSettingList().OrderedInsertL(newSetting);			
			}
		}
	// destroy local copy of settings
	settingsCopy.Reset();
	CleanupStack::PopAndDestroy(&settingsCopy);
	return error;		
	}


	//pure virtual functions to be implemented by CServerRepository and CPcRepImpl
	
	/**
	Retrieve the meta for a setting, look for the meta in the order of individual setting meta
	range meta and then default meta.
	*/
	virtual void GetSingleMeta(TUint aKey,TUint32& aMeta)=0;
	
	/**
	Retrieve the fall back policy associated with a setting
	*/
	virtual TSettingsAccessPolicy* GetFallbackAccessPolicy(TUint32 aId) const =0;
	
	/**
	Retrieve a pointer to a setting having the key specified in aKey
	*/
	virtual TServerSetting* GetSetting(TUint aKey)=0;
	
	/**
	Retrieve the settings that match the partial key and mask and add it into the settings pointer array
	*/
	virtual TInt FindSettings(TUint32 aSourcePartialKey,TUint32 aMask,RSettingPointerArray& aOutputArray) const=0;
	
	/**
	Get the list of settings array where modification should be made
	*/
	virtual RSettingsArray& GetWritableSettingList() =0;
};
#endif // OPERATIONS_H