// 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 the License "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:

// e32\debug\crashMonitor\src\scmconfig.cpp

// 

//

/**

 @file

 @internalTechnology

*/

#include <e32err.h>

#include <e32const.h>

#include <e32const_private.h>

#include <scmconfig.h>

#include <scmconfigitem.h>

#include <scmdatatypes.h>

namespace Debug

	{

	/**

	 * SCMConfiguration constructor

	 * Initialises the configuration object to default values

	 */

	SCMConfiguration::SCMConfiguration() 

	: iConfigList(NULL)

		{

		}

	/**

	 * SCMConfiguration destructor

	 */

	SCMConfiguration::~SCMConfiguration()

		{	

		ClearList();	

		}

	/**

	 * Goes to the flash and reads the configuration block and populates the object state

	 * accordingly

	 * @return one of the system wide error codes

	 */

	TInt SCMConfiguration::Deserialize(TByteStreamReader& aReader)

		{		

		if( !iConfigList)

			{

			// we need to set up a default configuration to load the data into

			TInt err = SetDefaultConfig();

			if(err != KErrNone)

				{

				CLTRACE1("SCMConfiguration::Deserialize SetDefaultConfig failed err = %d", err);

				return err;

				}

			}

		TInt startPos = aReader.CurrentPosition();		

		TBuf8<10> magicNumbers;

		// try and read the magic numbers - if they dont exist then 

		// there is not an scm config there

		const TInt KLen = KScmConfigHeaderString().Length();

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

			{

			TUint8 b = aReader.ReadByte();			

			magicNumbers.Append(TChar(b));	

			}

		if(magicNumbers.Compare(KScmConfigHeaderString()) != 0)

			{

			CLTRACE("No scm, config to read !");

			return KErrNotReady;

			}

		TConfigItem* item = iConfigList;

		while(item)

			{

			item->Deserialize(aReader);

			item = item->iNext;

			}

		TInt endPos = aReader.CurrentPosition();

		if( endPos - startPos != GetSize())

			{

			// error between actual size & real size in data

			CLTRACE("SCMConfiguration::Deserialize size error");	

			return KErrCorrupt;

			}			

		return KErrNone;			

		}

	/**

	 * This writes the current configuration object state to flash. This configuration will be used on the next crash

	 * @return one of the system wide error codes

	 */

	TInt SCMConfiguration::Serialize(TByteStreamWriter& aWriter)	

		{		

		if( !iConfigList)

			{

			CLTRACE("SCMConfiguration::Serialize ERROR - NO LIST!!");

			return KErrNotReady;

			}

		TInt startPos = aWriter.CurrentPosition();

		// write the number of crashes and magic numbers

		// try and read the magic numbers - if they dont exist then 

		// there is not an scm config there

		const TInt KLen = KScmConfigHeaderString().Length();

		const TDesC8& des = KScmConfigHeaderString();

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

			{

			aWriter.WriteByte(des[i]);

			}				

		TConfigItem* item = iConfigList;

		while(item)

			{

			item->Serialize(aWriter);

			item = item->iNext;

			}

		TInt endPos = aWriter.CurrentPosition();

		if( endPos - startPos != GetSize())

			{

			// error between actual size & real size in data

			CLTRACE("SCMConfiguration::Serialize size error");	

			return KErrCorrupt;

			}						

		return KErrNone;

		}

	/**

	 * Returns entire size of the SCMConfiguration block

	 * @return Size

	 */

	TInt SCMConfiguration::GetSize() const

		{

		// returns the size of all the config items when serialized to disk / flash

		return (TConfigItem::ELast * iConfigList->GetSize()) + KScmConfigHeaderString().Length();

		}

	/** 

	 * This will return, one at a time, the highest priority. 

	 * @see ResetToHighestPriority()

	 * @param aSizeToDump this will contain the size in bytes of data to dump for this type - 0 means dump all

	 * @return Data type to dump 

	 */

	TConfigItem* SCMConfiguration::GetNextItem()

		{

		if(!iNextItem)

			{

			return NULL;

			}

		//get the values we need

		TConfigItem* item  = iNextItem;	

		//Now move iNextItem to be next in the list

		iNextItem = iNextItem->iNext;			

		return item;

		}	

	/**

	 * Deletes the linked list

	 * @return system wide OS code

	 */

	void SCMConfiguration::ClearList()

		{

		if(!iConfigList)

			{

			return;

			}

		//all we need to do in here is delete the members of our linked list

		TConfigItem* item = iConfigList;

		do{			

			TConfigItem* tmp = item->iNext;

			delete item;		

			item = tmp;		

		}

		while(item != NULL);

		iConfigList = NULL;

		}

	/**

	 * Rather than reading the configuration from the flash, this method sets up the configuration object

	 * to a default configuration type

	 * @return one of the system wide error codes

	 */ 

	TInt SCMConfiguration::SetDefaultConfig()

		{

		//flush the object first

		ClearList();

		//This is a predefined default config - in the future we may have multiple defaults based on use case

		// currently however we use a fixed size list of config items of size TConfigItem::ELast		

		// also the TSCMDataType of each item must be unique				

		for(TInt cnt = TConfigItem::ELast - 1; cnt >= 0; cnt --)

			{			

			TInt priority = cnt + 1; 

			//Lets not do these by default

			if((TConfigItem::TSCMDataType)cnt == TConfigItem::EThreadsUsrStack || (TConfigItem::TSCMDataType)cnt == TConfigItem::EThreadsSvrStack)

				{

				priority = 0;

				}

			//set it with the priority of its enum (ie. assume that the enum is listed in its priority - it is)

			//by default dump everything until we run out of space

			TInt err = CreateConfigItem((TConfigItem::TSCMDataType)cnt, priority, 0);

			if(KErrNone != err)

				{

				return err;

				}

			}

		return KErrNone;		

		}

	/**

	 * This configures the required data for a given configuration item

	 * Note that aSizeToDump is only used in the case of memory dumps such as stacks

	 * @param aDataType - Type of data to dump

	 * @param aPriority - its priority 0-256. 0 Means do not dump and 256 is highest priority

	 * @param aSizeToDump - amount in bytes to dump. Only relevant for memory dumps and ignored when aPriority is 0

	 * @return one of the OS wide return codes

	 */

	TInt SCMConfiguration::CreateConfigItem(const TConfigItem::TSCMDataType aDataType, const TUint8 aPriority, const TInt32 aSizeToDump)

		{

		//create the config item

		TConfigItem* item = new TConfigItem(aDataType, aPriority, aSizeToDump);

		//insert to priority list

		return InsertToList(item);		

		}

	/**

	 * ModifyConfigItemPriority - modifies prioity for a given configuration item

	 * @param aDataType - The unique type of the config item

	 * @param aPriority - its priority 0-256. 0 Means do not dump and 256 is highest priority

	 * @return one of the OS wide return codes

	 */

	TInt  SCMConfiguration::ModifyConfigItemPriority(const TConfigItem::TSCMDataType aDataType, const TUint8 aPriority)

		{

		// find the item with the matching data type

		TConfigItem* item = iConfigList;		

		while(item)

			{

			if(item->iDataType == aDataType)

				{

				break;

				}

			item = item->iNext;			

			}

		if(!item)

			{

			return KErrNotFound;

			}

		item->iPriority = aPriority;

		// now reorder the list according to new priority

		TInt err = RemoveFromList(item);

		if(err != KErrNone)

			{

			return err;

			}

		err = InsertToList(item);

		if(err != KErrNone)

			{

			return err;

			}

		return KErrNone;

		}

/**

 * Removes item from the linked list

 * @param aItem - item to remove

 * @return OS code

 */

TInt SCMConfiguration::RemoveFromList(TConfigItem* aItem)

		{

		if(!aItem)

			{

			return KErrArgument;

			}

		if(!iConfigList)

			{

			return KErrCorrupt;  // oops no list to remove

			}

		if(aItem == iConfigList)

			{

			// special case remove from beginning of list

			iConfigList = iConfigList->iNext;

			return KErrNone;

			}

		TConfigItem* item = iConfigList; 

		while(item)

			{

			// is the next item the match ?

			if(item->iNext == aItem)

				{

				item->iNext = aItem->iNext;

				return KErrNone;

				}		

			item = item->iNext;	

			}

		return KErrNotFound;	

		}

/**

 * Inserts a priority item into the linked list in its correct location

 * @param aItem - item to insert

 * @return OS code

 */

TInt SCMConfiguration::InsertToList(TConfigItem* aItem)

	{ 	

	//if the list is empty, then this is the only item

	if(!iConfigList)

		{

		iConfigList = aItem;			

		return KErrNone;

		}

	//should it go at the start? special case not covered by while loop

	TConfigItem* temp;

	if(aItem->iPriority >= iConfigList->iPriority)

		{

		temp = iConfigList;

		iConfigList = aItem;

		aItem->iNext = temp;

		return KErrNone;

		}

	TConfigItem* item = iConfigList;

	do{		

		//if we get to the end of the list and the item still hasnt been assigned then it must be lowest priority

		if(item->iNext == NULL)

			{

			item->iNext = aItem;

			return KErrNone;

			}

		//check if its priority is between these

		if(aItem->iPriority < item->iPriority && aItem->iPriority >= item->iNext->iPriority)

			{

			//insert between these nodes

			temp = item->iNext;

			item->iNext = aItem;

			aItem->iNext = temp;

			return KErrNone;

			}

		item = item->iNext;	

	}

	while(item != NULL);	

	//should never get here

	return KErrUnknown;

	}

/**

 * This resets the next item counter back to the highest priority item in the list

 */

void SCMConfiguration::ResetToHighestPriority()

	{

	//set the next item counter back to the head of the list

	iNextItem = iConfigList;

	}

/**

 * Overloaded == operator

 * @param aOther Item to compare

 * @return

 */

TBool SCMConfiguration::operator == (const SCMConfiguration& aOther) const

	{

	if(!iConfigList && !aOther.iConfigList)

		{

		return ETrue;

		}

	if((!iConfigList && aOther.iConfigList) || (iConfigList && !aOther.iConfigList))

		{

		return EFalse;

		}

	TConfigItem* item1 = iConfigList;

	TConfigItem* item2 = aOther.iConfigList;

	while(item1 && item2)

		{

		if(!(*item1 == *item2))

			{

			return EFalse;

			}

		item1 = item1->iNext;			

		item2 = item2->iNext;			

		}

	if( item1 != item2)  // both should now be null - if not then lists were different lengths

		{

		return EFalse;

		}

	return ETrue;

	}

/**

 * Getter for the head of the SCMConfig list

 * @return Head of List

 */	

TConfigItem* SCMConfiguration::ConfigList() const

	{

	// returns the head of the list	

	return iConfigList;

	} 

} //End of debug namespace

//eof