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