/*

* 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:  Cache Manager class

 *

*/

#include "mulcachemanager.h"

#include <mul/imulvarianttype.h>

#include <mul/muldatapath.h>

#include <alf/alfvarianttype.h>

#include <alf/ialfmap.h>

#include <alf/ialfcontainer.h>

#include <mul/muldatapath.h>

#include <stdexcept>

#include <osn/ustring.h>

#include "mulassert.h"

#include "mulmodeldef.h"

#include "mulmodelimpl.h"

#include "mul/mulmodelutility.h"

#include "mullog.h"

namespace Alf

	{

// ---------------------------------------------------------------------------

// Constructor 

// ---------------------------------------------------------------------------

//

MulCacheManager::MulCacheManager()

			   : mTotalCount(0)

	{

	}

// ---------------------------------------------------------------------------

// Destructor 

// ---------------------------------------------------------------------------

//

MulCacheManager::~MulCacheManager()

	{	

	MulVisualItemMap::iterator itr;

	for( itr = mVisualItemMap.begin(); itr!= mVisualItemMap.end(); ++itr )

		{

		delete itr->second;

		itr->second = NULL;

		}

	mVisualItemMap.clear();

	}

// ---------------------------------------------------------------------------

// CreateNodes 

// ---------------------------------------------------------------------------

//

void MulCacheManager::CreateNodes(int aStartIndex, int aCount, const MulDataPath& /*aPath*/)

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::CreateNodes()");

	__MUL_ASSERT_DEBUG( aStartIndex >= 0 && aStartIndex <= ExpandedNodeCount() && aCount > 0 , KLInvalidArgument );

	if(mTotalCount > 0 && aStartIndex < mTotalCount )

		{

		UpdataPathInMapAfterInsert(mVisualItemMap, aStartIndex, aCount);

		UpdataPathInMapAfterInsert(mSelectionMap, aStartIndex, aCount);

		}

	mTotalCount += aCount;

	}

// ---------------------------------------------------------------------------

// AddVisualItem 

// ---------------------------------------------------------------------------

//

void MulCacheManager::AddVisualItem( std::auto_ptr<MulVisualItem> aVisualItem,

									const MulDataPath& /*aPath*/ , int aIndex)

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::AddVisualItem()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	//adding item now

	mVisualItemMap[aIndex] = aVisualItem.release();

	}

// ---------------------------------------------------------------------------

// AddVisualItem 

// ---------------------------------------------------------------------------

//

//void MulCacheManager::AddVisualItem( std::auto_ptr<MulVisualItem> aVisualItem, int aItemIndex )

//	{

//	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::AddVisualItem()");

//	__MUL_ASSERT_DEBUG( aItemIndex >= 0 && aItemIndex < ExpandedNodeCount() , KLInvalidArgument );

//	

//	MulDataPath path ;//= mTree.FindNode( aItemIndex );

//	AddVisualItem( aVisualItem, path, aItemIndex );

//	}

// ---------------------------------------------------------------------------

// RemoveVisualItem 

// ---------------------------------------------------------------------------

//

void MulCacheManager::RemoveVisualItem( int aIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::RemoveVisualItem()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	//MulDataPath path = mTree.FindNode( aIndex );

	MulDataPath path;

	RemoveItemFromMap( path, aIndex );	

	}

// ---------------------------------------------------------------------------

// RemoveVisualItem 

// ---------------------------------------------------------------------------

//

void MulCacheManager::RemoveVisualItem(const MulDataPath& aPath , int aIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::RemoveVisualItem()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	RemoveItemFromMap( aPath, aIndex );

	mSelectionMap.erase( aIndex ); //remove marking information for this path, index

	UpdataPathInMapAfterRemove( mVisualItemMap, aIndex,1 );	

	UpdataPathInMapAfterRemove( mSelectionMap, aIndex,1 );	

	mTotalCount--;

	}

// ---------------------------------------------------------------------------

// RemoveVisualItem 

// ---------------------------------------------------------------------------

//	

void MulCacheManager::RemoveVisualItem(int aIndex, int aCount, const MulDataPath& aPath)

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::RemoveVisualItem()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex+aCount <= ExpandedNodeCount() , KLInvalidArgument );

	for(int i = aIndex ; i < aIndex+aCount; i++ )	

		{

		RemoveItemFromMap( aPath, i );

		mSelectionMap.erase( i ); //remove marking information for this path, index

		}

	if(aIndex + aCount < ExpandedNodeCount() )

		{

		UpdataPathInMapAfterRemove( mVisualItemMap, aIndex, aCount);	

		UpdataPathInMapAfterRemove( mSelectionMap, aIndex, aCount );		

		}

	mTotalCount-= aCount;

	}

// ---------------------------------------------------------------------------

// RemoveItemFromMap 

// ---------------------------------------------------------------------------

//

void MulCacheManager::RemoveItemFromMap( const MulDataPath& /*aPath*/ , int aIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::RemoveItemFromMap()");

	MulVisualItemMap::iterator findIter = mVisualItemMap.find(aIndex);

	if( findIter!= mVisualItemMap.end() )

		{

		delete findIter->second;

		findIter->second = NULL;

		mVisualItemMap.erase( aIndex );

		}		

	}

// ---------------------------------------------------------------------------

// UpdataPathInMapAftreRemove 

// ---------------------------------------------------------------------------

//

template <typename T> void MulCacheManager::UpdataPathInMapAfterRemove( std::map<int,T >& aMap, int aIndex, int aCount )

	{	

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::UpdataPathInMapAfterRemove()");

	//loop through all items

	//for(int i = 0 ; i < ExpandedNodeCount() ; ++i )

	for(int i = aIndex ; i < ExpandedNodeCount() ; ++i )

		{

		// if index is greater than path index then index need to be modified

		//if( i >= aIndex )

			{	

			if( aMap.find( i ) != aMap.end() )

				{			

				T item = aMap.find( i )->second;

				aMap.erase( i );

				aMap[i-aCount] = item; //add item in to new index

				}

			}

		}

	}

// ---------------------------------------------------------------------------

// UpdataPathInMapAftreInsert 

// ---------------------------------------------------------------------------

//

template <typename T> void MulCacheManager::UpdataPathInMapAfterInsert( std::map<int,T >& aMap, int aIndex, int aCount )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::UpdataPathInMapAfterInsert()");

	//for( int i = ExpandedNodeCount() ; i > 0 ; --i )

	for( int i = ExpandedNodeCount() ; i >= aIndex ; --i )

        {

        // if index is greater than path index then index need to be modified

        //if( i >= aIndex )

            {   

            if( aMap.find( i ) != aMap.end() )

                {           

                T item = aMap.find( i )->second;

                aMap.erase( i );

                aMap[ i + aCount] = item; //add item in to new index

                }

            }

        }

	}

// ---------------------------------------------------------------------------

// UpdateVisualItem 

// ---------------------------------------------------------------------------

//

void MulCacheManager::UpdateVisualItem( MulVisualItem& aUpdatedVisualItem, int aItemIndex  )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::UpdateVisualItem()");

	__MUL_ASSERT_DEBUG( aItemIndex >= 0 && aItemIndex < ExpandedNodeCount() , KLInvalidArgument );

	MulDataPath path ;

	UpdateVisualItem( aUpdatedVisualItem, path, aItemIndex );

	}

// ---------------------------------------------------------------------------

// UpdateVisualItem 

// ---------------------------------------------------------------------------

//

void MulCacheManager::UpdateVisualItem( MulVisualItem& aVisualItem,const MulDataPath& /*aPath*/, int aIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::UpdateVisualItem()");

	MulVisualItem* visualItem = Data( aIndex );

	std::vector<mulvisualitem::TVisualAttribute> existingAttributes = aVisualItem.Attributes( );

	for( int i = 0 ; i < existingAttributes.size() ; ++i )

		{

		mulvisualitem::TVisualAttribute attributeName = existingAttributes[i];

		IMulVariantType* newValue = aVisualItem.Attribute( attributeName );

		if(newValue)

		    {

		    std::auto_ptr<IMulVariantType> cloneValue = newValue->Clone();

		   	int newflags = aVisualItem.Flag( attributeName );

		   	visualItem->SetAttribute( attributeName , cloneValue.get(), newflags );

		   	cloneValue.release();

		    }

		}

	visualItem->ResetDirtyAttribute(aVisualItem);

	}

// ---------------------------------------------------------------------------

// Data 

// ---------------------------------------------------------------------------

//

MulVisualItem* MulCacheManager::Data(const MulDataPath& /*aPath*/, int aIndex ) const

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::Data()");

	//__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	MulVisualItemMap::const_iterator findIter = mVisualItemMap.find(aIndex);

	if( findIter != mVisualItemMap.end() )

		{		

		return findIter->second;

		}

	else

		{

		return NULL;

		}

	}

// ---------------------------------------------------------------------------

// Data 

// ---------------------------------------------------------------------------

//

MulVisualItem* MulCacheManager::Data( int aIndex ) const

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::Data()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	MulDataPath path ;

	return Data( path, aIndex );

	}

// ---------------------------------------------------------------------------

// Count 

// ---------------------------------------------------------------------------

//

int MulCacheManager::Count() const

	{

	return mVisualItemMap.size();

	}

// ---------------------------------------------------------------------------

// ExpandedNodeCount 

// ---------------------------------------------------------------------------

//

int MulCacheManager::ExpandedNodeCount( ) const

	{

	//return mTree.ExpandedNodeCount();

	return mTotalCount;

	}

// ---------------------------------------------------------------------------

// SetMarkedIndices

// ---------------------------------------------------------------------------

//

void MulCacheManager::SetMarkedIndices( MulWidgetDef::TMulWidgetMarkingType aType ,

									 const std::vector<int>& aItemsIndex,

									 const MulDataPath& /*aPath*/)

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::SetMarkedIndices()");

	bool selection( false );

	// If selection type is not mark or unmark throw invalid argument exception

	aType == MulWidgetDef::EMulMark || aType == MulWidgetDef::EMulUnmark ?

	selection = ( aType == MulWidgetDef::EMulMark ) :

	throw std::invalid_argument( KInvalidArgument ); 

	// Add selected indices to vector and remove unselected

	for(int i = 0 ; i < aItemsIndex.size() ; i++ )

		{

		int  index = aItemsIndex[i];

		selection ? mSelectionMap[index] = index : mSelectionMap.erase(index);

		}	

	}

// ---------------------------------------------------------------------------

// SetMarkedIndices

// ---------------------------------------------------------------------------

//

void MulCacheManager::SetMarkedIndices(MulWidgetDef::TMulWidgetMarkingType aType)

	{	

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::SetMarkedIndices()");

	bool selection(false);

	// If selection type is not mark all or unmark all throw invalid argument exception

	aType == MulWidgetDef::EMulMarkAll || aType == MulWidgetDef::EMulUnmarkAll ?

	selection = ( aType == MulWidgetDef::EMulMarkAll ) :

	throw std::invalid_argument( KInvalidArgument ); 

	int count = ExpandedNodeCount();

	for(int i = 0 ; i < count ; ++i )

		{

		selection ? mSelectionMap[i] = i : mSelectionMap.erase(i);

		}		

	}

// ---------------------------------------------------------------------------

// MarkedIndices

// ---------------------------------------------------------------------------

//

const std::vector<int>& MulCacheManager::MarkedIndices( const MulDataPath& /*aPath*/  )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::MarkedIndices()");

	mSelectionVector.clear();

	int count = ExpandedNodeCount();

	for( int i=0; i < count ;++i )

		{

		MulSelectionMap::const_iterator itr = mSelectionMap.find(i);

		if(	itr != mSelectionMap.end() )

			{

			mSelectionVector.insert(i);

			}

		}

	return mSelectionVector.actualVector();	

	}

// ---------------------------------------------------------------------------

// IsItemMarked

// ---------------------------------------------------------------------------

//  

bool MulCacheManager::IsItemMarked( int aIndex ) const

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::IsItemMarked()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	MulSelectionMap::const_iterator itr = mSelectionMap.find( aIndex );	

	return ( itr != mSelectionMap.end() );

	}

// ---------------------------------------------------------------------------

// SetMarkedIndex

// ---------------------------------------------------------------------------

// 

void MulCacheManager::SetMarkedIndex( MulWidgetDef::TMulWidgetMarkingType aType, int aIndex )

	{

	MUL_LOG_ENTRY_EXIT("MUL::MulCacheManager::SetMarkedIndex()");

	__MUL_ASSERT_DEBUG( aIndex >= 0 && aIndex < ExpandedNodeCount() , KLInvalidArgument );

	bool selection( false );

	// If selection type is not mark or unmark throw invalid argument exception

	aType == MulWidgetDef::EMulMark || aType == MulWidgetDef::EMulUnmark ?

	selection = ( aType == MulWidgetDef::EMulMark ) :

	throw std::invalid_argument( KInvalidArgument ); 

	selection ? mSelectionMap[aIndex] = aIndex : mSelectionMap.erase(aIndex);

	}

} //end of namespace alf

//end of file