/*

* Copyright (c) 2007 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:   suite presentation model

*

*/

#include <e32cmn.h>

#include "hnsuitemodel.h"

#include "hnsuitemodelcontainer.h"

#include "hnitemmodel.h"

#include "hnmenuitemmodel.h"

#include "hnactionmodel.h"

#include "hntoolbarmodel.h"

#include "menudebug.h"

#include "hnglobals.h"

#include "hnsuiteobserver.h"

#include "hnattributebase.h"

#include "hnattributetext.h"

#include "hnitemsorder.h"

#include "hneventhandler.h"

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

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

// 

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

//

EXPORT_C CHnSuiteModel* CHnSuiteModel::NewL( CHnEventHandler& aEventHandler,

        const TDesC& aGenreName )

	{

	CHnSuiteModel* self = new (ELeave) CHnSuiteModel( aEventHandler );

	CleanupStack::PushL( self );

	self->ConstructL( aGenreName );

	CleanupStack::Pop( self );

	return self;

	}

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

// 

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

//

void CHnSuiteModel::ConstructL( const TDesC& aSuiteName )

	{

	ASSERT( aSuiteName.Length() );

	iSuiteName = aSuiteName.AllocL();

	iTemplate.CreateL( KNullDesC8() );

	iItemsOrder = CHnItemsOrder::NewL();

	iExitMode = EExitModeNormal;

	}

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

// 

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

//

EXPORT_C CHnSuiteModel::~CHnSuiteModel()

	{

    for (TInt i(0) ; i < iSuiteObservers.Count(); i++)

        {

        TRAP_IGNORE( iSuiteObservers[i]->HandleSuiteEventL( ESuiteModelDestroyed, this ) );

        }

    TRAP_IGNORE( OfferHnEventL( KIdSuiteUnLoad, 

            GetItemsOrder()->GetSuiteId(), NULL ) );

    DEBUG16(("\t_Mm_:KIdSuiteUnLoad - %S",iSuiteName));

	iSuiteObservers.Close();

	iObserverPriorities.Close();

	DEBUG16(("\t_MM_: CHnSuiteModel destructor: %S",iSuiteName));

	iTemplate.Close();

	delete iTitle;

	delete iEmptyText;

	delete iSuiteName;

	THashMapIter< TInt ,CHnItemModel* > modelIter( iItemsModels );

	while( modelIter.NextKey() )

		{

		const TInt* key = modelIter.CurrentKey();

		iItemsOrder->RemoveItemId( *key );

		CHnItemModel** model = modelIter.CurrentValue();

		delete *model;

		modelIter.RemoveCurrent();

		}

	iItemsModels.Close();

    THashMapIter< TInt, CArrayPtr<CHnActionModel>* > actionIter( iActions );

    while( actionIter.NextKey() )

        {

        CArrayPtr<CHnActionModel>** actions = actionIter.CurrentValue();

        (*actions)->ResetAndDestroy();

        delete *actions;

        actionIter.RemoveCurrent();

        }

    iActions.Close();

    delete iItemsOrder;

    DEBUG16(("\t_MM_: CHnSuiteModel destructor OUT"));

	}

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

// 

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

//

CHnSuiteModel::CHnSuiteModel( CHnEventHandler& aEventHandler ) :

        iItemsModels( &DefaultHash::Integer, &DefaultIdentity::Integer ),      

        iActions( &DefaultHash::Integer, &DefaultIdentity::Integer ),

        iEmptyItemId( KErrNotFound ),

        iFocusQueue( KErrNotFound ),

        iCustomId( KErrNotFound ),

        iEventHandler( aEventHandler ) 

	{

	iSuiteHighlight.iWidgetIndex = KErrNotFound;

	iSuiteHighlight.iItemId = KErrNotFound;

	iSuiteHighlight.iCustomId = KErrNotFound;

	}

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

//

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

//

TInt CHnSuiteModel::OfferHnEventL( 

       const TInt aEventId, const TInt aRecipientId, 

        CLiwGenericParamList* aEventParameters  )

    {

    TInt err( KErrNotFound );

    CArrayPtr<CHnActionModel>* actions = GetActions( aEventId );

    if ( aRecipientId != KErrNotFound )

        {       

        CHnItemModel** itemModel = iItemsModels.Find( aRecipientId );

        if ( itemModel && *itemModel )

            {

            err = (*itemModel)->OfferHnEventL( iEventHandler, aEventId,

                    aEventParameters);

            }

        }

    if ( err != KErrNone && actions) 

        {

        for( TInt i = 0; i < actions->Count(); i++ )

            {

            ASSERT( actions->At( i ) );

            err = actions->At( i )->ExecuteL( iEventHandler, aEventParameters );

            if ( err != KErrNone )

                {

                break;

                }

            }

        }

    return err;

    }

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

// 

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

// 

EXPORT_C TBool CHnSuiteModel::ItemEvaluationFinishedL( TInt aModelItemNumber )

    {

    TBool observersNotified( EFalse );

    TBool alreadyNotified = iItemsOrder->IsSuiteReadyToShow();

    iItemsOrder->ItemEvaluated( aModelItemNumber );

    if ( iItemsOrder->IsSuiteReadyToShow() && !alreadyNotified )

        {

        TRAP_IGNORE( OfferHnEventL( KIdSuiteLoad, 

                GetItemsOrder()->GetSuiteId(), NULL ) );

        DEBUG16(("\t_Mm_:KIdSuiteLoad - %S",iSuiteName));

        NotifyObserversL( ESuiteModelInitialized );

        observersNotified = ETrue;

        }

    return observersNotified;

    }

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

// 

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

//  

EXPORT_C TBool CHnSuiteModel::SuiteEvaluationFinishedL( )

    {

    TBool observersNotified( EFalse );

    TBool alreadyNotified = iItemsOrder->IsSuiteReadyToShow();

    iItemsOrder->SuiteEvaluated();

    if ( iItemsOrder->IsSuiteReadyToShow() && !alreadyNotified )

        {

        TRAP_IGNORE( OfferHnEventL( KIdSuiteLoad, 

                GetItemsOrder()->GetSuiteId(), NULL ) );

        DEBUG16(("\t_Mm_:KIdSuiteLoad - %S",iSuiteName));

        NotifyObserversL( ESuiteModelInitialized );

        observersNotified = ETrue;

        }

    return observersNotified;

    }

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

// 

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

//

EXPORT_C TInt CHnSuiteModel::GetItemModelsCount()

    {

    return iItemsModels.Count();

    }

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

// 

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

//

EXPORT_C const TDesC& CHnSuiteModel::SuiteName() const

	{

	return *iSuiteName;

	}

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

// 

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

//

EXPORT_C const TDesC& CHnSuiteModel::Title() const

	{

	if ( iTitle )

		{

		return *iTitle;

		}

	else

		{

		return KNullDesC();

		}

	}

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

// 

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

//

EXPORT_C void CHnSuiteModel::SetTitleL( const TDesC& aName )

	{

	delete iTitle;

	iTitle = NULL;

	iTitle = aName.AllocL();

	}

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

// 

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

//

EXPORT_C const TDesC& CHnSuiteModel::EmptyText() const

    {

    if ( iEmptyText )

        {

        return *iEmptyText;

        }

    else

        {

        return KNullDesC();

        }

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::SetEmptyTextL( const TDesC& aName )

    {

    delete iEmptyText;

    iEmptyText = NULL;

    iEmptyText = aName.AllocL();

    }

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

// 

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

//

EXPORT_C TInt CHnSuiteModel::WidgetType() const

	{

    //Following check is necessary because suite can be 

    //during evalutation -> UI Widgets can try to get and process templates

    //what causes problems. Only when suite is fully evaluated and 

    //ready to be shown it returns widget type.

	THnSuiteWidgetType ret( EUnspecified );

    if ( iItemsOrder->IsSuiteReadyToShow()  )

        {

        ret =  iWidgetType;

        }

	return ret;

	}

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

// 

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

//

EXPORT_C void CHnSuiteModel::SetWidgetType( THnSuiteWidgetType aWidgetType )

	{

	iWidgetType = aWidgetType;

	}

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

// 

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

//

EXPORT_C MHnMenuItemModelIterator* CHnSuiteModel::GetMenuStructureL( 

		TInt aItemId )

	{

	if (aItemId == KErrNotFound) 

	    {

	    // this could be used in future for empty item

	    return NULL;

	    }

	return iItemsModels.FindL( aItemId )->GetMenuStructure();

	}

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

// 

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

//

EXPORT_C void CHnSuiteModel::AddItemL( TInt aId, CHnItemModel* aItemModel,

        TInt aItemModelNumber, TInt aItemModelPosition )

	{

	DEBUG16(("_MM_: CHnSuiteModel::AddItemL IN"));

	ASSERT( aItemModel );

	TInt highlightedItem( iSuiteHighlight.iCustomId );

	iItemsModels.InsertL( aId, aItemModel );

	// "empty" item should not be added to ordering table

	if ( !aItemModel->GetTemplate().Compare( KTemplateEmpty8 ) )

	    {

	    // store id of empty item

	    iEmptyItemId = aId;	    

	    }

	else

	    {

	    iItemsOrder->InsertItemIdToL( aItemModelNumber, aItemModelPosition, aId );

	    DEBUG16(("_MM_: Adding at index: model no. %D item no. %D, id: %D", aItemModelNumber, aItemModelPosition, aId));

		// focus queue

		if ( ( iFocusQueue >= 0 ) && ( iFocusQueue == aItemModel->CustomId() ) )

			{

			SetSuiteHighlightL(  iItemsOrder->Count() - 1  );

			iFocusQueue = KErrGeneral ;

			}

		else if( aItemModel->CustomId() != KErrNotFound )

		    {

		    SetSuiteHighlightByCustomIdL( highlightedItem );

		    }

	    }

	DEBUG16(("_MM_: CHnSuiteModel::AddItemL OUT"));

	}

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

// 

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

//

EXPORT_C const TDesC8& CHnSuiteModel::GetTemplate() const

    {

    //Following check is necessary because suite can be 

    //during evalutation -> UI Widgets can try to get and process templates

    //what causes problems. Only when suite is fully evaluated and 

    //ready to be shown it returns templates.

    if ( iItemsOrder->IsSuiteReadyToShow()  )

        {

        return iTemplate;

        }

    return KNullDesC8;

    }

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

// 

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

//  

EXPORT_C void CHnSuiteModel::SetTemplateL( const TDesC8& aValue )

    {

    if( aValue.Compare( iTemplate ) )

    	{

    	iTemplate.Close();

    	iTemplate.CreateL( aValue.Length() + 1);

    	iTemplate.Copy( aValue );

    	const char* templateChar = reinterpret_cast<const char* >( 

                iTemplate.PtrZ() );

    	}

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::NotifyObserversL( THnCustomSuiteEvent aEventType )

    {

    RPointerArray<MHnSuiteObserver> observerFreezedArray;

    CleanupClosePushL( observerFreezedArray );

    for (TInt i(0); i < iSuiteObservers.Count(); i++)

        {

        observerFreezedArray.AppendL( iSuiteObservers[i] );

        }

    for (TInt i(0); i < observerFreezedArray.Count(); i++)

        {

        observerFreezedArray[i]->HandleSuiteEventL( aEventType, this );

        }

    CleanupStack::PopAndDestroy( &observerFreezedArray );

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::RefreshMulModelL( TInt aPreviousItemCount )

    {   

    if (iItemsOrder->IsSuiteReadyToShow())

    	{

		TInt modelcount = iItemsOrder->Count();

		if ( aPreviousItemCount < modelcount )

			{

			NotifyObserversL(ESuiteItemsAdded);

			}

		else if ( aPreviousItemCount > modelcount )

			{

			NotifyObserversL(ESuiteItemsRemoved);

			}    

		else

			{

			NotifyObserversL(ESuiteItemsUpdated);

			}

    	}

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::UpdateItemTemplateL( TInt aId )

	{

	TInt position = iItemsOrder->GetItemPosition( aId );

	if( position != KErrNotFound )

		{

		CHnItemModel** model = iItemsModels.Find( aId );

		if (model && !(*model)->GetTemplate().Compare( KNullDesC8() ) )

            {

            (*model)->SetTemplateL( GetTemplate() );

            }

		}

	}

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

// 

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

//

EXPORT_C void CHnSuiteModel::RegisterSuiteObserverL( MHnSuiteObserver* aObserver, 

        TThreadPriority aPriority )

    {

    TInt i(0);

    TInt posFound = iSuiteObservers.Find( aObserver );

    if ( posFound != KErrNotFound )

        {

        iObserverPriorities.Remove( posFound );

        iSuiteObservers.Remove( posFound ); 

        }

    for (; i < iObserverPriorities.Count(); i++)

        {

        if (aPriority > iObserverPriorities[i])

            {

            break;

            }

        }

    iObserverPriorities.InsertL( aPriority , i );

    iSuiteObservers.InsertL( aObserver, i );

    if ( iItemsOrder->IsSuiteReadyToShow() && posFound == KErrNotFound )

        {

        aObserver->HandleSuiteEventL( ESuiteModelInitialized, this );

        }

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::UnregisterSuiteObserver( MHnSuiteObserver* aObserver)

    {

    TInt index = iSuiteObservers.Find( aObserver );

    if (index != KErrNotFound)

        {

        iSuiteObservers.Remove( index );

        iObserverPriorities.Remove( index );

        }

    }

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

// 

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

//

EXPORT_C void CHnSuiteModel::RemoveItemL( TInt aId )

	{

    TInt highlightedItem( KErrNotFound );

	CHnItemModel* modelToRemove = GetItemModel( aId );

	if( modelToRemove )

	    {

	    if( modelToRemove->CustomId() != KErrNotFound )

	        {

	        if (modelToRemove->CustomId() != iSuiteHighlight.iCustomId )

				{

		        highlightedItem = iSuiteHighlight.iCustomId;

				}

	        else

	        	{

//	        	set the highlight to the item before the removed item.

	        	TInt newWidgetIndex = iItemsOrder->Count() - 2;

	        	if( newWidgetIndex < 0 )

	        		{

	        		newWidgetIndex = 0;

	        		}

	        	SetSuiteHighlightL( newWidgetIndex );

	        	}

	        }

	    delete modelToRemove;