/*
* 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:  Header for MulTree
*
*/


#ifndef MULTREE_H_
#define MULTREE_H_

#include <memory>
#include <vector>
#include <osn/osnnew.h>

namespace Alf
    {
//Forward declaration
class MulDataPath;
	
class MulTreeNode
	{
public:

	/**
	 * Constuctor
	 * 
	 * @param aIndex Index of this node
	 */
	MulTreeNode( int aIndex )
		{
		mParent = NULL;
		mExpandedState = false;
		mIndex = aIndex;
		}
	
	/**
	 * Constuctor
	 * 
	 * @param aParent Parent node for this node. Node dosent take ownership of aParent
	 * @param aIndex Index of this node
	 */
	MulTreeNode( MulTreeNode* aParent, int aIndex )
		{
		mParent = aParent;
		mExpandedState = false;
		mIndex = aIndex;
		}

	/**
	 * Destructor
	 */
	~MulTreeNode()
		{
		int count = mChilds.size();
		for(int i = 0 ; i < count ; ++i )
			{
			delete Child(i);
			}
		mChilds.clear();
		}
	
	/**
	 * Insert child node in this node at given index
	 * 
	 * @param aChild Child node.Takes ownership of aChild
	 * @param aIndex index at which child node to be inserted
	 */
	void InsertChild( std::auto_ptr<MulTreeNode> aChild, int aIndex )
		{
		aChild->mParent = this;
		mChilds.insert( mChilds.begin() + aIndex, aChild.get() );
		aChild.release();
		}
	
	/**
	 * Remove child node from this node.
	 * 
	 * @param aIndex Index of child that need to be removed
	 */
	void RemoveChild( int aIndex )
		{
		MulTreeNode* childNode = Child(aIndex);
		delete childNode;
		childNode = NULL;
		mChilds.erase( mChilds.begin() + aIndex );
		}
	
	/**
	 * Number of child node that this node contains
	 * 
	 * @return Number of childs
	 */
	int ChildCount() const
		{
		return mChilds.size();
		}
	
	/**
	 * Return child node at given index
	 * 
	 * @param aIndex index of child node
	 * @return Child node at given index
	 */
	MulTreeNode* Child( int aIndex )
		{
		//At checks for out of bound condition we dont need to check again
		return mChilds.at(aIndex);
		}
	
	/**
	 * Check that weather this node is parent node and has any childs
	 * 
	 * @retrun true if node has cilds false otherwise
	 */
	bool HasChild()	const		
		{	
		return ( ChildCount() > 0 );	
		}
	
	/**
	 * Return parent of this node
	 * 
	 * @return Parent of node
	 */
	MulTreeNode* Parent() const
		{
		return mParent;
		}
	
	/**
	 * Set Index of node to current path
	 * 
	 * @param aIndex index of node
	 */
	void SetIndex( int aIndex )
		{
		mIndex = aIndex;
		}

	/**
	 * Return index of node
	 * 
	 * @return index of node.
	 */
	int Index() const
		{
		return mIndex;
		}
	
	/**
	 * Expand or unexpand node.
	 * 
	 * @param aExpendedState New state of node
	 */
	void SetExpanded( bool aExpandedState )
		{
		mExpandedState = aExpandedState;
		}
	
	/**
	 * Return weather this node is expended or not
	 * 
	 * @return true if expended, false otherwise
	 */
	bool IsExpanded() const
		{
		return mExpandedState;
		}
	
private:

	MulTreeNode* mParent; //not own
	int mIndex;
	bool mExpandedState;
	std::vector<MulTreeNode*> mChilds; //owns all children	
	};

class MulTree 
	{
public: //Constructor and Destructor

	/**
	 * C++ Constructor
	 */
	MulTree()
		{
		//create root node for tree
		mRootNode.reset( new (EMM) MulTreeNode(0) );
		mRootNode->SetExpanded( true );
		mRootNode->SetIndex(0);
		}

	/**
	 * Destructor
	 */
	~MulTree()
		{
		}
	
public: //New method
	
	/**
	 * Create new node at specified index
	 * 
	 * @param aPath Path to parent node
	 * @param aIndex Position at which node to be inserted in parent node
	 */
	void AddNode( const MulDataPath& aPath, int aIndex );
	
	/**
	 * Remove node from specified index
	 * 
	 * @param aPath Path to parent node
	 * @param aIndex Posiotin at which node to be remove from parent node
	 */
	void RemoveNode( const MulDataPath& aPath, int aIndex );
	
	/**
	 * Finds node with specified path
	 * 
	 * @param aPath path of node to be find
	 * @return Node does not return ownership
	 */
    MulTreeNode* FindNode( const MulDataPath& aPath ) const;

	/**
	 * Finds node with specified index in specified node
	 * 
	 * @param aParentNode Parent node in which search required to be made
	 * @param aIndex Index of node to be find
	 * @return Node does not return ownership
	 */
	MulTreeNode* FindChildNode( MulTreeNode* aParentNode, int aIndex ) const;
	
	/**
	 * Find node with specified absolute index and return path to that node.
	 * 
	 * @param aIndex Index of node
	 * @return Path to node
	 */
	MulDataPath FindNode( int aIndex ) const;
		
	/**
	 * Create and return path for given node
	 * 
	 * @param aNode Node of which path is required
	 * @return Path of node
	 */
	MulDataPath Path( MulTreeNode& aNode ) const;
	
	/**
	 * Return number of node this tree contains
	 * 
	 * @return Number of nodes
	 */
	int NodeCount() const;
	
	/**
	 * Return number of node this node branch
	 * 
	 * @return Number of nodes
	 */
	int NodeCount(MulTreeNode* aCurrentNode ) const;
	
	/**
	 * Return number of items,
	 * Checks that node is expanded or not, 
	 * if expanded then add it counts child count else ignore child count.
	 * 
	 * @return Node count
	 */
	int ExpandedNodeCount() const;
	
	/**
	 * Return number of items,
	 * Checks that node is expanded or not, 
	 * if expanded then add it couts child count else ignore child count.
	 * 
	 * @param aCurrentNode Node of which count is needed
	 * 
	 * @return Node count
	 */
	int ExpandedNodeCount(MulTreeNode* aCurrentNode ) const;
	
	/**
	 * Returns node's absolute index
	 * 
	 * @param aPath Path to node
	 * @param aIndex index of node in path
	 * @return position of node in whole tree
	 */
	int NodeIndex( const MulDataPath& aPath, int aIndex ) const;
		
private:	

	/**
	 * Find node with specified absolute index and return path to that node.
	 * 
	 * @param aNode Node in which index to be find
	 * @param aIndex Index of node
	 * @return Path to node
	 */
	MulDataPath FindNode( MulTreeNode* aNode, int& aAbsoluteIndex, int aIndex ) const;
	
	/**
	 * Returns node's absolute index
	 * 
	 * @param aCurrentNode Node to compare path with
	 * @param aPath Path of node which absolute index is required
	 * @param aAbsoluteIndex Counter variable
	 * @return position of node in whole tree
	 */
	int NodeIndex( MulTreeNode* aCurrentNode, const MulDataPath& aPath,int& aAbsoluteIndex ) const;
	
private: //data

	std::auto_ptr<MulTreeNode> mRootNode; //root of tree - owned
	};
	
	} //namespace Alf

#endif /*MULTREE_H_*/