/*
* Copyright (c) 2007-2008 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:  MulTree Implementaiton
*
*/


#include "multree.h"

#include <stdexcept>

#include "mulassert.h"
#include "mulmodeldef.h"
#include "muldatapath.h"

namespace Alf
	{

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// AddNode
// -----------------------------------------------------------------------------
//
void MulTree::AddNode(const MulDataPath& aPath,int aIndex)
	{
	//Find parent node
	MulTreeNode* node = FindNode( aPath );
	
	//update index of other child
	for( int i = 0 ; i < node->ChildCount() ; i++ )
		{
		MulTreeNode* childNode = node->Child(i);
		int index = childNode->Index();
		if( childNode->Index() >= aIndex )
			{
			childNode->SetIndex( childNode->Index()+1 );
			}
		}	
	
	//insert node in to parent node
	std::auto_ptr<MulTreeNode> childNode( new (EMM) MulTreeNode(aIndex));
	node->InsertChild(childNode,aIndex);
	}

// -----------------------------------------------------------------------------
// RemoveNode
// -----------------------------------------------------------------------------
//
void MulTree::RemoveNode(const MulDataPath& aPath, int aIndex )
	{
	MulTreeNode* node = FindNode( aPath );
	node->RemoveChild(aIndex);
	
	//update index of other child
	for( int i = 0 ; i < node->ChildCount() ; i++ )
		{
		MulTreeNode* childNode = node->Child(i);
		int index = childNode->Index();
		if( childNode->Index() > aIndex )
			{
			childNode->SetIndex( childNode->Index()-1 );
			}
		}	
	}

// -----------------------------------------------------------------------------
// FindNode
// -----------------------------------------------------------------------------
//
MulTreeNode* MulTree::FindNode( const MulDataPath& aPath ) const
	{	
	MulTreeNode* currentNode = mRootNode.get();
	for( int i = 0; i < aPath.Depth() ;i++ )
		{
		int index = aPath[i];
		if( currentNode->HasChild() )
			{
			currentNode = FindChildNode( currentNode,index);
			}
		else
			{
			__MUL_ASSERT_DEBUG( false , KLInvalidArgument );
			}
		}
	return currentNode;
	}

// -----------------------------------------------------------------------------
// FindNode
// -----------------------------------------------------------------------------
//
MulTreeNode* MulTree::FindChildNode(MulTreeNode* aParentNode,int aIndex) const
	{
	MulTreeNode* currentNode = aParentNode;
	MulTreeNode* foundNode = NULL;
	int index = 0; 
	bool found(false);
	int childCount = currentNode->ChildCount();
	while( !found && index < childCount )
		{	
		MulTreeNode* childNode = currentNode->Child(index);
		if( aIndex == childNode->Index() )
			{
			found = true;
			foundNode = childNode;
			}
		index++;
		}
		
	if( found == false )
		{
		__MUL_ASSERT_DEBUG( false , KLInvalidArgument );
		}
		
	return foundNode;
	}

// -----------------------------------------------------------------------------
// FindNode
// -----------------------------------------------------------------------------
//
MulDataPath MulTree::FindNode( int aIndex ) const
	{	
	int absoluteIndex = -1;
	return FindNode( mRootNode.get(), absoluteIndex, aIndex );	
	}

// -----------------------------------------------------------------------------
// FindNode
// -----------------------------------------------------------------------------
//
MulDataPath MulTree::FindNode( MulTreeNode* aNode, int& aAbsoluteIndex, int aIndex ) const
	{	
	MulTreeNode* currentNode = aNode;
	if( currentNode->HasChild() )
		{
		for(int i = 0 ; i < currentNode->ChildCount() ; i++ )
			{
			aAbsoluteIndex++;
			MulTreeNode* childNode = currentNode->Child(i);
			
#ifdef _DEBUG
			bool hasChild = childNode->HasChild();
			int count = childNode->ChildCount();
			bool isExpanded = childNode->IsExpanded();
#endif //_DEBUG
			
			if( aAbsoluteIndex == aIndex )
				{
				MulDataPath path= Path(*childNode);
				path.SetIndex(i);
				return path;
				}
			 else if( childNode->HasChild() && childNode->IsExpanded() )
				{
				MulDataPath path = FindNode( childNode, aAbsoluteIndex , aIndex );
				if(path.Index() != KNotInitialized )
					{
					return path;
					}
				}			
			}
		}
	//__MUL_ASSERT_DEBUG( false , KLInvalidArgument );
	MulDataPath path;
	path.SetIndex(KNotInitialized);
	return path; 
	}

// -----------------------------------------------------------------------------
// Path
// -----------------------------------------------------------------------------
//
MulDataPath MulTree::Path(MulTreeNode& aNode) const
	{
	MulTreeNode* parentNode = aNode.Parent();
	std::vector<int> pathArray;
	while( parentNode && parentNode != mRootNode.get() )
		{
		int index = parentNode->Index();
		pathArray.push_back( parentNode->Index() );
		parentNode = parentNode->Parent();
		}
	
	int count = pathArray.size();
	
	MulDataPath path;
	for( int i= pathArray.size()- 1 ; i >=0 ; i-- )
		{
		path.Append( pathArray[i] );
		}
	pathArray.clear();
	return path;
	}

// -----------------------------------------------------------------------------
// NodeCount
// -----------------------------------------------------------------------------
//
int MulTree::NodeCount() const
	{
	int nodeCount =NodeCount( mRootNode.get() );
	return nodeCount;
	}

// -----------------------------------------------------------------------------
// NodeCount
// -----------------------------------------------------------------------------
//
int MulTree::NodeCount(MulTreeNode* aCurrentNode ) const
	{
	int nodeCount = 0;
	if(aCurrentNode->HasChild())
		{
		nodeCount = aCurrentNode->ChildCount();
		for(int i=0;i< aCurrentNode->ChildCount();i++)
			{
			nodeCount+= NodeCount(aCurrentNode->Child(i));
			}
		}
	return nodeCount;
	}

// -----------------------------------------------------------------------------
// ExpandedNodeCount
// -----------------------------------------------------------------------------
//
int MulTree::ExpandedNodeCount() const
	{
	int nodeCount = ExpandedNodeCount( mRootNode.get() );
	return nodeCount;
	}

// -----------------------------------------------------------------------------
// ExpandedNodeCount
// -----------------------------------------------------------------------------
//
int MulTree::ExpandedNodeCount(MulTreeNode* aCurrentNode ) const
	{
	int nodeCount = 0;
	if( aCurrentNode->HasChild() && aCurrentNode->IsExpanded() )
		{
		nodeCount = aCurrentNode->ChildCount();
		for( int i=0; i< aCurrentNode->ChildCount() ; i++ )
			{
			nodeCount+= ExpandedNodeCount( aCurrentNode->Child(i) );
			}
		}
	return nodeCount;
	}

// -----------------------------------------------------------------------------
// NodeIndex
// -----------------------------------------------------------------------------
//
int MulTree::NodeIndex( const MulDataPath& aPath, int aIndex ) const
	{
	MulDataPath path( aPath );
	path.SetIndex( aIndex );
	
	int absoluteIndex = -1;
	int index = NodeIndex( mRootNode.get(), path, absoluteIndex );
	
	return index;
	}

// -----------------------------------------------------------------------------
// NodeIndex
// -----------------------------------------------------------------------------
//
int MulTree::NodeIndex( MulTreeNode* aCurrentNode, const MulDataPath& aPath, int& aAbsoluteIndex ) const
	{	
	MulTreeNode* currentNode = aCurrentNode;
	if( currentNode->HasChild() )
		{
		for(int i = 0 ; i < currentNode->ChildCount() ; i++ )
			{
			aAbsoluteIndex++;
			MulTreeNode* childNode = currentNode->Child(i);
			
#ifdef _DEBUG
			bool hasChild = childNode->HasChild();
			int count = childNode->ChildCount();
			bool isExpanded = childNode->IsExpanded();
#endif //_DEBUG
			
			MulDataPath path = Path(*childNode);
			path.SetIndex(i);
			
			if( path.IsEqual(aPath) )
				{
				return aAbsoluteIndex;
				}
			 else if( childNode->HasChild() && childNode->IsExpanded() )
				{
				int index = NodeIndex( childNode, aPath, aAbsoluteIndex );
				if( index != KNotInitialized )
					{
					return index;
					}
				}			
			}
		}
	return KNotInitialized; 
	}
		
	} //namespace Alf
	
	//End of file